// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: band/tunnel/v1beta1/tx.proto

package types

import (
	context "context"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	types "github.com/cosmos/cosmos-sdk/codec/types"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types1 "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/cosmos-sdk/types/msgservice"
	_ "github.com/cosmos/cosmos-sdk/types/tx/amino"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// MsgCreateTunnel is the transaction message to create a new tunnel.
type MsgCreateTunnel struct {
	// signal_deviations is the list of signal deviations.
	SignalDeviations []SignalDeviation `protobuf:"bytes,1,rep,name=signal_deviations,json=signalDeviations,proto3" json:"signal_deviations"`
	// interval is the interval for delivering the signal prices in seconds.
	Interval uint64 `protobuf:"varint,2,opt,name=interval,proto3" json:"interval,omitempty"`
	// route is the route for delivering the signal prices
	Route *types.Any `protobuf:"bytes,3,opt,name=route,proto3" json:"route,omitempty"`
	// initial_deposit is the deposit value that must be paid at tunnel creation.
	InitialDeposit github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,4,rep,name=initial_deposit,json=initialDeposit,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"initial_deposit"`
	// creator is the address of the creator.
	Creator string `protobuf:"bytes,5,opt,name=creator,proto3" json:"creator,omitempty"`
}

func (m *MsgCreateTunnel) Reset()         { *m = MsgCreateTunnel{} }
func (m *MsgCreateTunnel) String() string { return proto.CompactTextString(m) }
func (*MsgCreateTunnel) ProtoMessage()    {}
func (*MsgCreateTunnel) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{0}
}
func (m *MsgCreateTunnel) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgCreateTunnel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgCreateTunnel.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgCreateTunnel) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgCreateTunnel.Merge(m, src)
}
func (m *MsgCreateTunnel) XXX_Size() int {
	return m.Size()
}
func (m *MsgCreateTunnel) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreateTunnel.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreateTunnel proto.InternalMessageInfo

func (m *MsgCreateTunnel) GetSignalDeviations() []SignalDeviation {
	if m != nil {
		return m.SignalDeviations
	}
	return nil
}

func (m *MsgCreateTunnel) GetInterval() uint64 {
	if m != nil {
		return m.Interval
	}
	return 0
}

func (m *MsgCreateTunnel) GetRoute() *types.Any {
	if m != nil {
		return m.Route
	}
	return nil
}

func (m *MsgCreateTunnel) GetInitialDeposit() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.InitialDeposit
	}
	return nil
}

func (m *MsgCreateTunnel) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

// MsgCreateTunnelResponse is the response type for the Msg/CreateTunnel RPC method.
type MsgCreateTunnelResponse struct {
	TunnelID uint64 `protobuf:"varint,1,opt,name=tunnel_id,json=tunnelId,proto3" json:"tunnel_id,omitempty"`
}

func (m *MsgCreateTunnelResponse) Reset()         { *m = MsgCreateTunnelResponse{} }
func (m *MsgCreateTunnelResponse) String() string { return proto.CompactTextString(m) }
func (*MsgCreateTunnelResponse) ProtoMessage()    {}
func (*MsgCreateTunnelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{1}
}
func (m *MsgCreateTunnelResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgCreateTunnelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgCreateTunnelResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgCreateTunnelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgCreateTunnelResponse.Merge(m, src)
}
func (m *MsgCreateTunnelResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgCreateTunnelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreateTunnelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreateTunnelResponse proto.InternalMessageInfo

func (m *MsgCreateTunnelResponse) GetTunnelID() uint64 {
	if m != nil {
		return m.TunnelID
	}
	return 0
}

// MsgUpdateRoute is the transaction message to update a route information of the tunnel.
type MsgUpdateRoute struct {
	// tunnel_id is the ID of the tunnel to edit.
	TunnelID uint64 `protobuf:"varint,1,opt,name=tunnel_id,json=tunnelId,proto3" json:"tunnel_id,omitempty"`
	// route is the route for delivering the signal prices
	Route *types.Any `protobuf:"bytes,2,opt,name=route,proto3" json:"route,omitempty"`
	// creator is the address of the creator.
	Creator string `protobuf:"bytes,3,opt,name=creator,proto3" json:"creator,omitempty"`
}

func (m *MsgUpdateRoute) Reset()         { *m = MsgUpdateRoute{} }
func (m *MsgUpdateRoute) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateRoute) ProtoMessage()    {}
func (*MsgUpdateRoute) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{2}
}
func (m *MsgUpdateRoute) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUpdateRoute) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUpdateRoute.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgUpdateRoute) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUpdateRoute.Merge(m, src)
}
func (m *MsgUpdateRoute) XXX_Size() int {
	return m.Size()
}
func (m *MsgUpdateRoute) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUpdateRoute.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateRoute proto.InternalMessageInfo

func (m *MsgUpdateRoute) GetTunnelID() uint64 {
	if m != nil {
		return m.TunnelID
	}
	return 0
}

func (m *MsgUpdateRoute) GetRoute() *types.Any {
	if m != nil {
		return m.Route
	}
	return nil
}

func (m *MsgUpdateRoute) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

// MsgUpdateRouteResponse is the response type for the Msg/UpdateRoute RPC method.
type MsgUpdateRouteResponse struct {
}

func (m *MsgUpdateRouteResponse) Reset()         { *m = MsgUpdateRouteResponse{} }
func (m *MsgUpdateRouteResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateRouteResponse) ProtoMessage()    {}
func (*MsgUpdateRouteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{3}
}
func (m *MsgUpdateRouteResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUpdateRouteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUpdateRouteResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgUpdateRouteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUpdateRouteResponse.Merge(m, src)
}
func (m *MsgUpdateRouteResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgUpdateRouteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUpdateRouteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateRouteResponse proto.InternalMessageInfo

// MsgUpdateSignalsAndInterval is the transaction message to update signals and interval of the tunnel.
type MsgUpdateSignalsAndInterval struct {
	// tunnel_id is the ID of the tunnel to edit.
	TunnelID uint64 `protobuf:"varint,1,opt,name=tunnel_id,json=tunnelId,proto3" json:"tunnel_id,omitempty"`
	// signal_deviations is the list of signal deviations.
	SignalDeviations []SignalDeviation `protobuf:"bytes,2,rep,name=signal_deviations,json=signalDeviations,proto3" json:"signal_deviations"`
	// interval is the interval for delivering the signal prices.
	Interval uint64 `protobuf:"varint,3,opt,name=interval,proto3" json:"interval,omitempty"`
	// creator is the address of the creator.
	Creator string `protobuf:"bytes,4,opt,name=creator,proto3" json:"creator,omitempty"`
}

func (m *MsgUpdateSignalsAndInterval) Reset()         { *m = MsgUpdateSignalsAndInterval{} }
func (m *MsgUpdateSignalsAndInterval) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateSignalsAndInterval) ProtoMessage()    {}
func (*MsgUpdateSignalsAndInterval) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{4}
}
func (m *MsgUpdateSignalsAndInterval) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUpdateSignalsAndInterval) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUpdateSignalsAndInterval.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgUpdateSignalsAndInterval) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUpdateSignalsAndInterval.Merge(m, src)
}
func (m *MsgUpdateSignalsAndInterval) XXX_Size() int {
	return m.Size()
}
func (m *MsgUpdateSignalsAndInterval) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUpdateSignalsAndInterval.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateSignalsAndInterval proto.InternalMessageInfo

func (m *MsgUpdateSignalsAndInterval) GetTunnelID() uint64 {
	if m != nil {
		return m.TunnelID
	}
	return 0
}

func (m *MsgUpdateSignalsAndInterval) GetSignalDeviations() []SignalDeviation {
	if m != nil {
		return m.SignalDeviations
	}
	return nil
}

func (m *MsgUpdateSignalsAndInterval) GetInterval() uint64 {
	if m != nil {
		return m.Interval
	}
	return 0
}

func (m *MsgUpdateSignalsAndInterval) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

// MsgUpdateSignalsAndIntervalResponse is the response type for the Msg/UpdateSignalsAndInterval RPC method.
type MsgUpdateSignalsAndIntervalResponse struct {
}

func (m *MsgUpdateSignalsAndIntervalResponse) Reset()         { *m = MsgUpdateSignalsAndIntervalResponse{} }
func (m *MsgUpdateSignalsAndIntervalResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateSignalsAndIntervalResponse) ProtoMessage()    {}
func (*MsgUpdateSignalsAndIntervalResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{5}
}
func (m *MsgUpdateSignalsAndIntervalResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUpdateSignalsAndIntervalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUpdateSignalsAndIntervalResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgUpdateSignalsAndIntervalResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUpdateSignalsAndIntervalResponse.Merge(m, src)
}
func (m *MsgUpdateSignalsAndIntervalResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgUpdateSignalsAndIntervalResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUpdateSignalsAndIntervalResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateSignalsAndIntervalResponse proto.InternalMessageInfo

// MsgWithdrawFeePayerFunds is the transaction message to withdraw fee payer funds to creator.
type MsgWithdrawFeePayerFunds struct {
	// tunnel_id is the ID of the tunnel to withdraw fee payer coins.
	TunnelID uint64 `protobuf:"varint,1,opt,name=tunnel_id,json=tunnelId,proto3" json:"tunnel_id,omitempty"`
	// amount is the coins to withdraw.
	Amount github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=amount,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"amount"`
	// creator is the address of the creator.
	Creator string `protobuf:"bytes,3,opt,name=creator,proto3" json:"creator,omitempty"`
}

func (m *MsgWithdrawFeePayerFunds) Reset()         { *m = MsgWithdrawFeePayerFunds{} }
func (m *MsgWithdrawFeePayerFunds) String() string { return proto.CompactTextString(m) }
func (*MsgWithdrawFeePayerFunds) ProtoMessage()    {}
func (*MsgWithdrawFeePayerFunds) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{6}
}
func (m *MsgWithdrawFeePayerFunds) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgWithdrawFeePayerFunds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgWithdrawFeePayerFunds.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgWithdrawFeePayerFunds) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgWithdrawFeePayerFunds.Merge(m, src)
}
func (m *MsgWithdrawFeePayerFunds) XXX_Size() int {
	return m.Size()
}
func (m *MsgWithdrawFeePayerFunds) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgWithdrawFeePayerFunds.DiscardUnknown(m)
}

var xxx_messageInfo_MsgWithdrawFeePayerFunds proto.InternalMessageInfo

func (m *MsgWithdrawFeePayerFunds) GetTunnelID() uint64 {
	if m != nil {
		return m.TunnelID
	}
	return 0
}

func (m *MsgWithdrawFeePayerFunds) GetAmount() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Amount
	}
	return nil
}

func (m *MsgWithdrawFeePayerFunds) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

// MsgWithdrawFeePayerFundsResponse is the response type for the Msg/WithdrawFeePayerFunds RPC method.
type MsgWithdrawFeePayerFundsResponse struct {
}

func (m *MsgWithdrawFeePayerFundsResponse) Reset()         { *m = MsgWithdrawFeePayerFundsResponse{} }
func (m *MsgWithdrawFeePayerFundsResponse) String() string { return proto.CompactTextString(m) }
func (*MsgWithdrawFeePayerFundsResponse) ProtoMessage()    {}
func (*MsgWithdrawFeePayerFundsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{7}
}
func (m *MsgWithdrawFeePayerFundsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgWithdrawFeePayerFundsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgWithdrawFeePayerFundsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgWithdrawFeePayerFundsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgWithdrawFeePayerFundsResponse.Merge(m, src)
}
func (m *MsgWithdrawFeePayerFundsResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgWithdrawFeePayerFundsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgWithdrawFeePayerFundsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgWithdrawFeePayerFundsResponse proto.InternalMessageInfo

// MsgActivateTunnel is the transaction message to activate a tunnel.
type MsgActivateTunnel struct {
	// tunnel_id is the ID of the tunnel to activate.
	TunnelID uint64 `protobuf:"varint,1,opt,name=tunnel_id,json=tunnelId,proto3" json:"tunnel_id,omitempty"`
	// creator is the address of the creator.
	Creator string `protobuf:"bytes,2,opt,name=creator,proto3" json:"creator,omitempty"`
}

func (m *MsgActivateTunnel) Reset()         { *m = MsgActivateTunnel{} }
func (m *MsgActivateTunnel) String() string { return proto.CompactTextString(m) }
func (*MsgActivateTunnel) ProtoMessage()    {}
func (*MsgActivateTunnel) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{8}
}
func (m *MsgActivateTunnel) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgActivateTunnel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgActivateTunnel.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgActivateTunnel) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgActivateTunnel.Merge(m, src)
}
func (m *MsgActivateTunnel) XXX_Size() int {
	return m.Size()
}
func (m *MsgActivateTunnel) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgActivateTunnel.DiscardUnknown(m)
}

var xxx_messageInfo_MsgActivateTunnel proto.InternalMessageInfo

func (m *MsgActivateTunnel) GetTunnelID() uint64 {
	if m != nil {
		return m.TunnelID
	}
	return 0
}

func (m *MsgActivateTunnel) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

// MsgActivateTunnelResponse is the response type for the Msg/Activate RPC method.
type MsgActivateTunnelResponse struct {
}

func (m *MsgActivateTunnelResponse) Reset()         { *m = MsgActivateTunnelResponse{} }
func (m *MsgActivateTunnelResponse) String() string { return proto.CompactTextString(m) }
func (*MsgActivateTunnelResponse) ProtoMessage()    {}
func (*MsgActivateTunnelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{9}
}
func (m *MsgActivateTunnelResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgActivateTunnelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgActivateTunnelResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgActivateTunnelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgActivateTunnelResponse.Merge(m, src)
}
func (m *MsgActivateTunnelResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgActivateTunnelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgActivateTunnelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgActivateTunnelResponse proto.InternalMessageInfo

// MsgDeactivateTunnel is the transaction message to deactivate a tunnel.
type MsgDeactivateTunnel struct {
	// tunnel_id is the ID of the tunnel to deactivate.
	TunnelID uint64 `protobuf:"varint,1,opt,name=tunnel_id,json=tunnelId,proto3" json:"tunnel_id,omitempty"`
	// creator is the address of the creator.
	Creator string `protobuf:"bytes,2,opt,name=creator,proto3" json:"creator,omitempty"`
}

func (m *MsgDeactivateTunnel) Reset()         { *m = MsgDeactivateTunnel{} }
func (m *MsgDeactivateTunnel) String() string { return proto.CompactTextString(m) }
func (*MsgDeactivateTunnel) ProtoMessage()    {}
func (*MsgDeactivateTunnel) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{10}
}
func (m *MsgDeactivateTunnel) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgDeactivateTunnel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgDeactivateTunnel.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgDeactivateTunnel) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgDeactivateTunnel.Merge(m, src)
}
func (m *MsgDeactivateTunnel) XXX_Size() int {
	return m.Size()
}
func (m *MsgDeactivateTunnel) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgDeactivateTunnel.DiscardUnknown(m)
}

var xxx_messageInfo_MsgDeactivateTunnel proto.InternalMessageInfo

func (m *MsgDeactivateTunnel) GetTunnelID() uint64 {
	if m != nil {
		return m.TunnelID
	}
	return 0
}

func (m *MsgDeactivateTunnel) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

// MsgDeactivateTunnelResponse is the response type for the Msg/Deactivate RPC method.
type MsgDeactivateTunnelResponse struct {
}

func (m *MsgDeactivateTunnelResponse) Reset()         { *m = MsgDeactivateTunnelResponse{} }
func (m *MsgDeactivateTunnelResponse) String() string { return proto.CompactTextString(m) }
func (*MsgDeactivateTunnelResponse) ProtoMessage()    {}
func (*MsgDeactivateTunnelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{11}
}
func (m *MsgDeactivateTunnelResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgDeactivateTunnelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgDeactivateTunnelResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgDeactivateTunnelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgDeactivateTunnelResponse.Merge(m, src)
}
func (m *MsgDeactivateTunnelResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgDeactivateTunnelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgDeactivateTunnelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgDeactivateTunnelResponse proto.InternalMessageInfo

// MsgTriggerTunnel is the transaction message to manually trigger a tunnel.
type MsgTriggerTunnel struct {
	// tunnel_id is the ID of the tunnel to manually trigger.
	TunnelID uint64 `protobuf:"varint,1,opt,name=tunnel_id,json=tunnelId,proto3" json:"tunnel_id,omitempty"`
	// creator is the address of the creator.
	Creator string `protobuf:"bytes,2,opt,name=creator,proto3" json:"creator,omitempty"`
}

func (m *MsgTriggerTunnel) Reset()         { *m = MsgTriggerTunnel{} }
func (m *MsgTriggerTunnel) String() string { return proto.CompactTextString(m) }
func (*MsgTriggerTunnel) ProtoMessage()    {}
func (*MsgTriggerTunnel) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{12}
}
func (m *MsgTriggerTunnel) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgTriggerTunnel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgTriggerTunnel.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgTriggerTunnel) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgTriggerTunnel.Merge(m, src)
}
func (m *MsgTriggerTunnel) XXX_Size() int {
	return m.Size()
}
func (m *MsgTriggerTunnel) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgTriggerTunnel.DiscardUnknown(m)
}

var xxx_messageInfo_MsgTriggerTunnel proto.InternalMessageInfo

func (m *MsgTriggerTunnel) GetTunnelID() uint64 {
	if m != nil {
		return m.TunnelID
	}
	return 0
}

func (m *MsgTriggerTunnel) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

// MsgTriggerTunnelResponse is the response type for the Msg/TriggerTunnel RPC method.
type MsgTriggerTunnelResponse struct {
}

func (m *MsgTriggerTunnelResponse) Reset()         { *m = MsgTriggerTunnelResponse{} }
func (m *MsgTriggerTunnelResponse) String() string { return proto.CompactTextString(m) }
func (*MsgTriggerTunnelResponse) ProtoMessage()    {}
func (*MsgTriggerTunnelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{13}
}
func (m *MsgTriggerTunnelResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgTriggerTunnelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgTriggerTunnelResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgTriggerTunnelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgTriggerTunnelResponse.Merge(m, src)
}
func (m *MsgTriggerTunnelResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgTriggerTunnelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgTriggerTunnelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgTriggerTunnelResponse proto.InternalMessageInfo

// MsgDepositToTunnel defines a message to deposit to an existing tunnel.
type MsgDepositToTunnel struct {
	// tunnel_id defines the unique id of the tunnel.
	TunnelID uint64 `protobuf:"varint,1,opt,name=tunnel_id,json=tunnelId,proto3" json:"tunnel_id,omitempty"`
	// amount to be deposited by depositor.
	Amount github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=amount,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"amount"`
	// depositor defines the deposit addresses from the tunnel.
	Depositor string `protobuf:"bytes,3,opt,name=depositor,proto3" json:"depositor,omitempty"`
}

func (m *MsgDepositToTunnel) Reset()         { *m = MsgDepositToTunnel{} }
func (m *MsgDepositToTunnel) String() string { return proto.CompactTextString(m) }
func (*MsgDepositToTunnel) ProtoMessage()    {}
func (*MsgDepositToTunnel) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{14}
}
func (m *MsgDepositToTunnel) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgDepositToTunnel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgDepositToTunnel.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgDepositToTunnel) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgDepositToTunnel.Merge(m, src)
}
func (m *MsgDepositToTunnel) XXX_Size() int {
	return m.Size()
}
func (m *MsgDepositToTunnel) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgDepositToTunnel.DiscardUnknown(m)
}

var xxx_messageInfo_MsgDepositToTunnel proto.InternalMessageInfo

func (m *MsgDepositToTunnel) GetTunnelID() uint64 {
	if m != nil {
		return m.TunnelID
	}
	return 0
}

func (m *MsgDepositToTunnel) GetAmount() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Amount
	}
	return nil
}

func (m *MsgDepositToTunnel) GetDepositor() string {
	if m != nil {
		return m.Depositor
	}
	return ""
}

// MsgDepositToTunnelResponse defines the Msg/DepositToTunnel response type.
type MsgDepositToTunnelResponse struct {
}

func (m *MsgDepositToTunnelResponse) Reset()         { *m = MsgDepositToTunnelResponse{} }
func (m *MsgDepositToTunnelResponse) String() string { return proto.CompactTextString(m) }
func (*MsgDepositToTunnelResponse) ProtoMessage()    {}
func (*MsgDepositToTunnelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{15}
}
func (m *MsgDepositToTunnelResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgDepositToTunnelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgDepositToTunnelResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgDepositToTunnelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgDepositToTunnelResponse.Merge(m, src)
}
func (m *MsgDepositToTunnelResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgDepositToTunnelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgDepositToTunnelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgDepositToTunnelResponse proto.InternalMessageInfo

// MsgWithdrawFromTunnel is the transaction message to withdraw a deposit from an existing tunnel.
type MsgWithdrawFromTunnel struct {
	// tunnel_id defines the unique id of the tunnel.
	TunnelID uint64 `protobuf:"varint,1,opt,name=tunnel_id,json=tunnelId,proto3" json:"tunnel_id,omitempty"`
	// amount to be withdrawn by withdrawer.
	Amount github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=amount,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"amount"`
	// withdrawer defines the withdraw addresses from the tunnel.
	Withdrawer string `protobuf:"bytes,3,opt,name=withdrawer,proto3" json:"withdrawer,omitempty"`
}

func (m *MsgWithdrawFromTunnel) Reset()         { *m = MsgWithdrawFromTunnel{} }
func (m *MsgWithdrawFromTunnel) String() string { return proto.CompactTextString(m) }
func (*MsgWithdrawFromTunnel) ProtoMessage()    {}
func (*MsgWithdrawFromTunnel) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{16}
}
func (m *MsgWithdrawFromTunnel) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgWithdrawFromTunnel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgWithdrawFromTunnel.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgWithdrawFromTunnel) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgWithdrawFromTunnel.Merge(m, src)
}
func (m *MsgWithdrawFromTunnel) XXX_Size() int {
	return m.Size()
}
func (m *MsgWithdrawFromTunnel) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgWithdrawFromTunnel.DiscardUnknown(m)
}

var xxx_messageInfo_MsgWithdrawFromTunnel proto.InternalMessageInfo

func (m *MsgWithdrawFromTunnel) GetTunnelID() uint64 {
	if m != nil {
		return m.TunnelID
	}
	return 0
}

func (m *MsgWithdrawFromTunnel) GetAmount() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Amount
	}
	return nil
}

func (m *MsgWithdrawFromTunnel) GetWithdrawer() string {
	if m != nil {
		return m.Withdrawer
	}
	return ""
}

// MsgWithdrawFromTunnelResponse defines the Msg/WithdrawFromTunnel response type.
type MsgWithdrawFromTunnelResponse struct {
}

func (m *MsgWithdrawFromTunnelResponse) Reset()         { *m = MsgWithdrawFromTunnelResponse{} }
func (m *MsgWithdrawFromTunnelResponse) String() string { return proto.CompactTextString(m) }
func (*MsgWithdrawFromTunnelResponse) ProtoMessage()    {}
func (*MsgWithdrawFromTunnelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{17}
}
func (m *MsgWithdrawFromTunnelResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgWithdrawFromTunnelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgWithdrawFromTunnelResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgWithdrawFromTunnelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgWithdrawFromTunnelResponse.Merge(m, src)
}
func (m *MsgWithdrawFromTunnelResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgWithdrawFromTunnelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgWithdrawFromTunnelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgWithdrawFromTunnelResponse proto.InternalMessageInfo

// MsgUpdateParams is the transaction message to update parameters.
type MsgUpdateParams struct {
	// authority is the address of the governance account.
	Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
	// params is the x/tunnel parameters to update.
	Params Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params"`
}

func (m *MsgUpdateParams) Reset()         { *m = MsgUpdateParams{} }
func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateParams) ProtoMessage()    {}
func (*MsgUpdateParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{18}
}
func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUpdateParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUpdateParams.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgUpdateParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUpdateParams.Merge(m, src)
}
func (m *MsgUpdateParams) XXX_Size() int {
	return m.Size()
}
func (m *MsgUpdateParams) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUpdateParams.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateParams proto.InternalMessageInfo

func (m *MsgUpdateParams) GetAuthority() string {
	if m != nil {
		return m.Authority
	}
	return ""
}

func (m *MsgUpdateParams) GetParams() Params {
	if m != nil {
		return m.Params
	}
	return Params{}
}

// MsgUpdateParamsResponse is the response type for the Msg/UpdateParams RPC method.
type MsgUpdateParamsResponse struct {
}

func (m *MsgUpdateParamsResponse) Reset()         { *m = MsgUpdateParamsResponse{} }
func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateParamsResponse) ProtoMessage()    {}
func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d18351d83b4705d0, []int{19}
}
func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUpdateParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUpdateParamsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgUpdateParamsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUpdateParamsResponse.Merge(m, src)
}
func (m *MsgUpdateParamsResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUpdateParamsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgCreateTunnel)(nil), "band.tunnel.v1beta1.MsgCreateTunnel")
	proto.RegisterType((*MsgCreateTunnelResponse)(nil), "band.tunnel.v1beta1.MsgCreateTunnelResponse")
	proto.RegisterType((*MsgUpdateRoute)(nil), "band.tunnel.v1beta1.MsgUpdateRoute")
	proto.RegisterType((*MsgUpdateRouteResponse)(nil), "band.tunnel.v1beta1.MsgUpdateRouteResponse")
	proto.RegisterType((*MsgUpdateSignalsAndInterval)(nil), "band.tunnel.v1beta1.MsgUpdateSignalsAndInterval")
	proto.RegisterType((*MsgUpdateSignalsAndIntervalResponse)(nil), "band.tunnel.v1beta1.MsgUpdateSignalsAndIntervalResponse")
	proto.RegisterType((*MsgWithdrawFeePayerFunds)(nil), "band.tunnel.v1beta1.MsgWithdrawFeePayerFunds")
	proto.RegisterType((*MsgWithdrawFeePayerFundsResponse)(nil), "band.tunnel.v1beta1.MsgWithdrawFeePayerFundsResponse")
	proto.RegisterType((*MsgActivateTunnel)(nil), "band.tunnel.v1beta1.MsgActivateTunnel")
	proto.RegisterType((*MsgActivateTunnelResponse)(nil), "band.tunnel.v1beta1.MsgActivateTunnelResponse")
	proto.RegisterType((*MsgDeactivateTunnel)(nil), "band.tunnel.v1beta1.MsgDeactivateTunnel")
	proto.RegisterType((*MsgDeactivateTunnelResponse)(nil), "band.tunnel.v1beta1.MsgDeactivateTunnelResponse")
	proto.RegisterType((*MsgTriggerTunnel)(nil), "band.tunnel.v1beta1.MsgTriggerTunnel")
	proto.RegisterType((*MsgTriggerTunnelResponse)(nil), "band.tunnel.v1beta1.MsgTriggerTunnelResponse")
	proto.RegisterType((*MsgDepositToTunnel)(nil), "band.tunnel.v1beta1.MsgDepositToTunnel")
	proto.RegisterType((*MsgDepositToTunnelResponse)(nil), "band.tunnel.v1beta1.MsgDepositToTunnelResponse")
	proto.RegisterType((*MsgWithdrawFromTunnel)(nil), "band.tunnel.v1beta1.MsgWithdrawFromTunnel")
	proto.RegisterType((*MsgWithdrawFromTunnelResponse)(nil), "band.tunnel.v1beta1.MsgWithdrawFromTunnelResponse")
	proto.RegisterType((*MsgUpdateParams)(nil), "band.tunnel.v1beta1.MsgUpdateParams")
	proto.RegisterType((*MsgUpdateParamsResponse)(nil), "band.tunnel.v1beta1.MsgUpdateParamsResponse")
}

func init() { proto.RegisterFile("band/tunnel/v1beta1/tx.proto", fileDescriptor_d18351d83b4705d0) }

var fileDescriptor_d18351d83b4705d0 = []byte{
	// 1117 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0xbd, 0x6f, 0xdb, 0x46,
	0x14, 0x37, 0x25, 0xdb, 0xb5, 0x9f, 0x5d, 0x7f, 0x30, 0x76, 0x4c, 0xd1, 0x8e, 0x2c, 0x30, 0x5f,
	0x8a, 0x13, 0x93, 0xfe, 0x40, 0x82, 0x34, 0x9b, 0x15, 0x23, 0x80, 0x07, 0x01, 0x81, 0xe2, 0x22,
	0x40, 0x17, 0x83, 0x12, 0xaf, 0x14, 0x11, 0x8b, 0x27, 0xf0, 0x4e, 0x4a, 0x34, 0x14, 0x28, 0x3a,
	0x74, 0xe8, 0xd2, 0x2e, 0x2d, 0x0a, 0x14, 0x1d, 0xba, 0x14, 0x45, 0x97, 0x7a, 0xc8, 0x1f, 0x11,
	0x74, 0x69, 0xd0, 0xa9, 0x53, 0xda, 0xda, 0x83, 0xff, 0x8d, 0x82, 0xc7, 0xd3, 0xf1, 0xc3, 0x94,
	0x43, 0x15, 0x81, 0x91, 0x45, 0x12, 0xdf, 0xfb, 0xdd, 0xbd, 0xdf, 0xfb, 0x1d, 0xdf, 0xbd, 0x27,
	0x58, 0xa9, 0x9b, 0xae, 0x65, 0xd0, 0x8e, 0xeb, 0xa2, 0x43, 0xa3, 0xbb, 0x59, 0x47, 0xd4, 0xdc,
	0x34, 0xe8, 0x0b, 0xbd, 0xed, 0x61, 0x8a, 0xe5, 0x4b, 0xbe, 0x57, 0x0f, 0xbc, 0x3a, 0xf7, 0xaa,
	0x05, 0x1b, 0x63, 0xfb, 0x10, 0x19, 0x0c, 0x52, 0xef, 0x7c, 0x6a, 0x98, 0x6e, 0x2f, 0xc0, 0xab,
	0x0b, 0x36, 0xb6, 0x31, 0xfb, 0x69, 0xf8, 0xbf, 0xb8, 0xb5, 0xd0, 0xc0, 0xa4, 0x85, 0xc9, 0x41,
	0xe0, 0x08, 0x1e, 0xb8, 0xab, 0x18, 0x3c, 0x19, 0x75, 0x93, 0x20, 0x11, 0xbe, 0x81, 0x1d, 0x97,
	0xfb, 0x97, 0xb8, 0xbf, 0x45, 0x6c, 0xa3, 0xbb, 0xe9, 0x7f, 0x71, 0xc7, 0xbc, 0xd9, 0x72, 0x5c,
	0x6c, 0xb0, 0x4f, 0x6e, 0x2a, 0xa5, 0xa5, 0xd2, 0x36, 0x3d, 0xb3, 0x45, 0xce, 0x43, 0xf0, 0xec,
	0x18, 0x42, 0xfb, 0x2e, 0x0f, 0xb3, 0x55, 0x62, 0x3f, 0xf4, 0x90, 0x49, 0xd1, 0x3e, 0xf3, 0xc8,
	0x4f, 0x61, 0x9e, 0x38, 0xb6, 0x6b, 0x1e, 0x1e, 0x58, 0xa8, 0xeb, 0x98, 0xd4, 0xc1, 0x2e, 0x51,
	0xa4, 0x52, 0xbe, 0x3c, 0xb5, 0x75, 0x4d, 0x4f, 0x11, 0x48, 0x7f, 0xc2, 0xd0, 0xbb, 0x7d, 0x70,
	0x65, 0xf4, 0xd5, 0x9b, 0xd5, 0x91, 0xda, 0x1c, 0x89, 0x9b, 0x89, 0xac, 0xc2, 0x84, 0xe3, 0x52,
	0xe4, 0x75, 0xcd, 0x43, 0x25, 0x57, 0x92, 0xca, 0xa3, 0x35, 0xf1, 0x2c, 0xdf, 0x83, 0x31, 0x0f,
	0x77, 0x28, 0x52, 0xf2, 0x25, 0xa9, 0x3c, 0xb5, 0xb5, 0xa0, 0x07, 0xa2, 0xeb, 0x7d, 0xd1, 0xf5,
	0x1d, 0xb7, 0x57, 0x81, 0xdf, 0x5f, 0xae, 0x8f, 0xd7, 0x7c, 0xd8, 0x5e, 0x2d, 0x80, 0xcb, 0x3d,
	0x98, 0x75, 0x5c, 0x87, 0x3a, 0x8c, 0x6d, 0x1b, 0x13, 0x87, 0x2a, 0xa3, 0x8c, 0x6a, 0x41, 0xe7,
	0xc2, 0xfb, 0x52, 0x0b, 0xaa, 0x0f, 0xb1, 0xe3, 0x56, 0xee, 0xfa, 0xfc, 0x7e, 0xfd, 0x7b, 0xb5,
	0x6c, 0x3b, 0xb4, 0xd9, 0xa9, 0xeb, 0x0d, 0xdc, 0xe2, 0xa7, 0xc4, 0xbf, 0xd6, 0x89, 0xf5, 0xcc,
	0xa0, 0xbd, 0x36, 0x22, 0x6c, 0x01, 0xf9, 0xe5, 0xf4, 0x68, 0x4d, 0xaa, 0xcd, 0xf0, 0x40, 0xbb,
	0x41, 0x1c, 0x79, 0x0b, 0x3e, 0x68, 0xf8, 0xba, 0x61, 0x4f, 0x19, 0x2b, 0x49, 0xe5, 0xc9, 0x8a,
	0xf2, 0xe7, 0xcb, 0xf5, 0x05, 0x1e, 0x75, 0xc7, 0xb2, 0x3c, 0x44, 0xc8, 0x13, 0xea, 0x39, 0xae,
	0x5d, 0xeb, 0x03, 0x1f, 0xdc, 0xfc, 0xe2, 0xf4, 0x68, 0xad, 0xff, 0xf4, 0xd5, 0xe9, 0xd1, 0xda,
	0x65, 0x7e, 0x3a, 0x89, 0x43, 0xd0, 0x76, 0x61, 0x29, 0x61, 0xaa, 0x21, 0xd2, 0xc6, 0x2e, 0x41,
	0xf2, 0x2d, 0x98, 0x0c, 0x16, 0x1d, 0x38, 0x96, 0x22, 0xf9, 0x3a, 0x56, 0xa6, 0x8f, 0xdf, 0xac,
	0x4e, 0x04, 0xb0, 0xbd, 0xdd, 0xda, 0x44, 0xe0, 0xde, 0xb3, 0xb4, 0x3f, 0x24, 0x98, 0xa9, 0x12,
	0xfb, 0xe3, 0xb6, 0x65, 0x52, 0xc4, 0x84, 0x1b, 0x62, 0x75, 0x78, 0x26, 0xb9, 0xe1, 0xce, 0x24,
	0x22, 0x4c, 0x3e, 0xab, 0x30, 0x37, 0x92, 0xc2, 0x2c, 0x86, 0xc2, 0x44, 0xe8, 0x6b, 0x0a, 0x5c,
	0x8e, 0x5b, 0xfa, 0xb2, 0x68, 0x3f, 0xe7, 0x60, 0x59, 0xb8, 0x82, 0x57, 0x92, 0xec, 0xb8, 0xd6,
	0x5e, 0xff, 0x0d, 0x1b, 0x22, 0xf1, 0xd4, 0x0a, 0xc8, 0xbd, 0xe3, 0x0a, 0xc8, 0x27, 0x2a, 0x20,
	0xa2, 0xda, 0x68, 0x56, 0xd5, 0xb6, 0x93, 0xaa, 0x69, 0x49, 0xd5, 0xce, 0x0a, 0xa1, 0x5d, 0x87,
	0xab, 0xe7, 0xb8, 0x85, 0x9e, 0xdf, 0xe6, 0x40, 0xa9, 0x12, 0xfb, 0xa9, 0x43, 0x9b, 0x96, 0x67,
	0x3e, 0x7f, 0x84, 0xd0, 0x63, 0xb3, 0x87, 0xbc, 0x47, 0x1d, 0xd7, 0x22, 0xc3, 0x88, 0xd9, 0x84,
	0x71, 0xb3, 0x85, 0x3b, 0x2e, 0xe5, 0x0a, 0xbe, 0xfb, 0xc2, 0xe4, 0xfb, 0xff, 0xaf, 0xf7, 0x6e,
	0x23, 0xa9, 0xe0, 0x6a, 0xa8, 0x60, 0x6a, 0xea, 0x9a, 0x06, 0xa5, 0x41, 0x3e, 0xa1, 0xdd, 0x8f,
	0x12, 0xcc, 0x57, 0x89, 0xbd, 0xd3, 0xa0, 0x4e, 0x37, 0xbc, 0x58, 0x87, 0x10, 0x2d, 0x92, 0x4a,
	0x2e, 0x6b, 0x2a, 0xb7, 0x92, 0xa9, 0x28, 0x61, 0x2a, 0x71, 0x26, 0xda, 0x32, 0x14, 0xce, 0x18,
	0x05, 0xf9, 0x9f, 0x24, 0xb8, 0x54, 0x25, 0xf6, 0x2e, 0x32, 0x2f, 0x94, 0xfe, 0xed, 0x24, 0x7d,
	0x35, 0xa4, 0x9f, 0xe4, 0xa2, 0x5d, 0x61, 0xb5, 0x9e, 0x34, 0x8b, 0x14, 0x7e, 0x90, 0x60, 0xae,
	0x4a, 0xec, 0x7d, 0xcf, 0xb1, 0x6d, 0xe4, 0x5d, 0x0c, 0xff, 0x72, 0x92, 0xff, 0x52, 0xc8, 0x3f,
	0x46, 0x44, 0x53, 0x59, 0x61, 0xc5, 0x6c, 0x82, 0xf9, 0xd7, 0x39, 0x90, 0x59, 0x66, 0xac, 0xc7,
	0xec, 0xe3, 0xe1, 0xb9, 0x5f, 0x5c, 0xbd, 0xdd, 0x83, 0x49, 0xde, 0x73, 0x33, 0x54, 0x5c, 0x08,
	0x7d, 0x70, 0xc7, 0x57, 0x2a, 0x7c, 0xf6, 0xb5, 0x2a, 0x44, 0xcf, 0x3a, 0x96, 0xba, 0xb6, 0x02,
	0xea, 0x59, 0xab, 0xd0, 0xeb, 0xfb, 0x1c, 0x2c, 0x46, 0xcb, 0xd1, 0xc3, 0xad, 0xf7, 0x59, 0xb2,
	0xfb, 0x00, 0xcf, 0x39, 0x55, 0xf4, 0x76, 0xcd, 0x22, 0xd8, 0xe0, 0xa2, 0x8a, 0x18, 0x7c, 0xd5,
	0x56, 0x52, 0xee, 0x2a, 0x21, 0x80, 0xb6, 0x0a, 0x57, 0x52, 0x1d, 0x42, 0xbb, 0xdf, 0x24, 0x36,
	0xfc, 0x05, 0x9d, 0xe0, 0x31, 0x1b, 0x1c, 0xfd, 0x33, 0x35, 0x3b, 0xb4, 0x89, 0x3d, 0x87, 0xf6,
	0x98, 0x6a, 0xe7, 0x9e, 0xa9, 0x80, 0xca, 0x1f, 0xc1, 0x78, 0x30, 0x7a, 0xf2, 0x61, 0x61, 0x39,
	0xb5, 0x4f, 0x06, 0x41, 0x78, 0x7b, 0xe4, 0x0b, 0x82, 0x7b, 0x2b, 0xdc, 0x2a, 0x31, 0x15, 0x45,
	0xd9, 0x69, 0x05, 0x36, 0x15, 0x45, 0x4d, 0xfd, 0x64, 0xb6, 0xfe, 0x9d, 0x80, 0x7c, 0x95, 0xd8,
	0x72, 0x1d, 0xa6, 0x63, 0xd3, 0x6c, 0x7a, 0xc3, 0x4e, 0xcc, 0x56, 0xea, 0x9d, 0x2c, 0x28, 0x31,
	0x81, 0x1d, 0xc0, 0x54, 0x74, 0xa4, 0xba, 0x3a, 0x68, 0x71, 0x04, 0xa4, 0xde, 0xce, 0x00, 0x12,
	0x01, 0xbe, 0x94, 0x40, 0x19, 0x38, 0xc8, 0x6c, 0x9c, 0xbf, 0xd3, 0xd9, 0x15, 0xea, 0xfd, 0x61,
	0x57, 0x08, 0x22, 0x9f, 0xc1, 0x62, 0xfa, 0x00, 0xb0, 0x3e, 0x68, 0xcb, 0x54, 0xb8, 0x7a, 0x77,
	0x28, 0xb8, 0x08, 0xdf, 0x84, 0x99, 0x44, 0x0f, 0xbd, 0x31, 0x68, 0xa3, 0x38, 0x4e, 0xd5, 0xb3,
	0xe1, 0x44, 0x24, 0x17, 0xe6, 0xce, 0x34, 0xbc, 0xf2, 0xa0, 0x3d, 0x92, 0x48, 0x75, 0x23, 0x2b,
	0x52, 0xc4, 0x43, 0xf0, 0x61, 0xbc, 0x3b, 0x5d, 0x1f, 0xb4, 0x45, 0x0c, 0xa6, 0xae, 0x67, 0x82,
	0x89, 0x30, 0xcf, 0x60, 0x36, 0xd9, 0x4a, 0x6e, 0x0e, 0xe6, 0x1a, 0x03, 0xaa, 0x46, 0x46, 0xa0,
	0x08, 0x46, 0x41, 0x4e, 0xb9, 0x87, 0xd7, 0xde, 0x7a, 0xf4, 0x02, 0xab, 0x6e, 0x65, 0xc7, 0x8a,
	0xa8, 0x75, 0x98, 0x8e, 0xdd, 0x60, 0xd7, 0xce, 0x7f, 0xd9, 0x03, 0xd4, 0xe0, 0x82, 0x4f, 0xbb,
	0x5c, 0xd4, 0xb1, 0xcf, 0xfd, 0x5b, 0xbc, 0xb2, 0xf7, 0xea, 0xb8, 0x28, 0xbd, 0x3e, 0x2e, 0x4a,
	0xff, 0x1c, 0x17, 0xa5, 0x6f, 0x4e, 0x8a, 0x23, 0xaf, 0x4f, 0x8a, 0x23, 0x7f, 0x9d, 0x14, 0x47,
	0x3e, 0x31, 0x22, 0xed, 0xc0, 0xdf, 0x98, 0xfd, 0x45, 0x6a, 0xe0, 0x43, 0xa3, 0xd1, 0x34, 0x1d,
	0xd7, 0xe8, 0x6e, 0x1b, 0x2f, 0xfa, 0xff, 0xc3, 0x59, 0x6f, 0xa8, 0x8f, 0x33, 0xc4, 0xf6, 0x7f,
	0x01, 0x00, 0x00, 0xff, 0xff, 0x8c, 0xdd, 0x4e, 0xda, 0x90, 0x10, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// MsgClient is the client API for Msg service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MsgClient interface {
	// CreateTunnel is a RPC method to create a new tunnel.
	CreateTunnel(ctx context.Context, in *MsgCreateTunnel, opts ...grpc.CallOption) (*MsgCreateTunnelResponse, error)
	// UpdateRoute is a RPC method to update a route information of the tunnel.
	UpdateRoute(ctx context.Context, in *MsgUpdateRoute, opts ...grpc.CallOption) (*MsgUpdateRouteResponse, error)
	// UpdateSignalsAndInterval is a RPC method to update a signals and interval of the tunnel.
	UpdateSignalsAndInterval(ctx context.Context, in *MsgUpdateSignalsAndInterval, opts ...grpc.CallOption) (*MsgUpdateSignalsAndIntervalResponse, error)
	// WithdrawFeePayerFunds is a RPC method to withdraw fee payer funds to creator.
	WithdrawFeePayerFunds(ctx context.Context, in *MsgWithdrawFeePayerFunds, opts ...grpc.CallOption) (*MsgWithdrawFeePayerFundsResponse, error)
	// ActivateTunnel is a RPC method to activate a tunnel.
	ActivateTunnel(ctx context.Context, in *MsgActivateTunnel, opts ...grpc.CallOption) (*MsgActivateTunnelResponse, error)
	// DeactivateTunnel is a RPC method to deactivate a tunnel.
	DeactivateTunnel(ctx context.Context, in *MsgDeactivateTunnel, opts ...grpc.CallOption) (*MsgDeactivateTunnelResponse, error)
	// TriggerTunnel is a RPC method to manually trigger a tunnel.
	TriggerTunnel(ctx context.Context, in *MsgTriggerTunnel, opts ...grpc.CallOption) (*MsgTriggerTunnelResponse, error)
	// DepositToTunnel is a RPC method to deposit to an existing tunnel.
	DepositToTunnel(ctx context.Context, in *MsgDepositToTunnel, opts ...grpc.CallOption) (*MsgDepositToTunnelResponse, error)
	// WithdrawFromTunnel is a RPC method to withdraw a deposit from an existing tunnel.
	WithdrawFromTunnel(ctx context.Context, in *MsgWithdrawFromTunnel, opts ...grpc.CallOption) (*MsgWithdrawFromTunnelResponse, error)
	// UpdateParams is a RPC method to update parameters
	UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

func NewMsgClient(cc grpc1.ClientConn) MsgClient {
	return &msgClient{cc}
}

func (c *msgClient) CreateTunnel(ctx context.Context, in *MsgCreateTunnel, opts ...grpc.CallOption) (*MsgCreateTunnelResponse, error) {
	out := new(MsgCreateTunnelResponse)
	err := c.cc.Invoke(ctx, "/band.tunnel.v1beta1.Msg/CreateTunnel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdateRoute(ctx context.Context, in *MsgUpdateRoute, opts ...grpc.CallOption) (*MsgUpdateRouteResponse, error) {
	out := new(MsgUpdateRouteResponse)
	err := c.cc.Invoke(ctx, "/band.tunnel.v1beta1.Msg/UpdateRoute", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdateSignalsAndInterval(ctx context.Context, in *MsgUpdateSignalsAndInterval, opts ...grpc.CallOption) (*MsgUpdateSignalsAndIntervalResponse, error) {
	out := new(MsgUpdateSignalsAndIntervalResponse)
	err := c.cc.Invoke(ctx, "/band.tunnel.v1beta1.Msg/UpdateSignalsAndInterval", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) WithdrawFeePayerFunds(ctx context.Context, in *MsgWithdrawFeePayerFunds, opts ...grpc.CallOption) (*MsgWithdrawFeePayerFundsResponse, error) {
	out := new(MsgWithdrawFeePayerFundsResponse)
	err := c.cc.Invoke(ctx, "/band.tunnel.v1beta1.Msg/WithdrawFeePayerFunds", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) ActivateTunnel(ctx context.Context, in *MsgActivateTunnel, opts ...grpc.CallOption) (*MsgActivateTunnelResponse, error) {
	out := new(MsgActivateTunnelResponse)
	err := c.cc.Invoke(ctx, "/band.tunnel.v1beta1.Msg/ActivateTunnel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) DeactivateTunnel(ctx context.Context, in *MsgDeactivateTunnel, opts ...grpc.CallOption) (*MsgDeactivateTunnelResponse, error) {
	out := new(MsgDeactivateTunnelResponse)
	err := c.cc.Invoke(ctx, "/band.tunnel.v1beta1.Msg/DeactivateTunnel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) TriggerTunnel(ctx context.Context, in *MsgTriggerTunnel, opts ...grpc.CallOption) (*MsgTriggerTunnelResponse, error) {
	out := new(MsgTriggerTunnelResponse)
	err := c.cc.Invoke(ctx, "/band.tunnel.v1beta1.Msg/TriggerTunnel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) DepositToTunnel(ctx context.Context, in *MsgDepositToTunnel, opts ...grpc.CallOption) (*MsgDepositToTunnelResponse, error) {
	out := new(MsgDepositToTunnelResponse)
	err := c.cc.Invoke(ctx, "/band.tunnel.v1beta1.Msg/DepositToTunnel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) WithdrawFromTunnel(ctx context.Context, in *MsgWithdrawFromTunnel, opts ...grpc.CallOption) (*MsgWithdrawFromTunnelResponse, error) {
	out := new(MsgWithdrawFromTunnelResponse)
	err := c.cc.Invoke(ctx, "/band.tunnel.v1beta1.Msg/WithdrawFromTunnel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) {
	out := new(MsgUpdateParamsResponse)
	err := c.cc.Invoke(ctx, "/band.tunnel.v1beta1.Msg/UpdateParams", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// CreateTunnel is a RPC method to create a new tunnel.
	CreateTunnel(context.Context, *MsgCreateTunnel) (*MsgCreateTunnelResponse, error)
	// UpdateRoute is a RPC method to update a route information of the tunnel.
	UpdateRoute(context.Context, *MsgUpdateRoute) (*MsgUpdateRouteResponse, error)
	// UpdateSignalsAndInterval is a RPC method to update a signals and interval of the tunnel.
	UpdateSignalsAndInterval(context.Context, *MsgUpdateSignalsAndInterval) (*MsgUpdateSignalsAndIntervalResponse, error)
	// WithdrawFeePayerFunds is a RPC method to withdraw fee payer funds to creator.
	WithdrawFeePayerFunds(context.Context, *MsgWithdrawFeePayerFunds) (*MsgWithdrawFeePayerFundsResponse, error)
	// ActivateTunnel is a RPC method to activate a tunnel.
	ActivateTunnel(context.Context, *MsgActivateTunnel) (*MsgActivateTunnelResponse, error)
	// DeactivateTunnel is a RPC method to deactivate a tunnel.
	DeactivateTunnel(context.Context, *MsgDeactivateTunnel) (*MsgDeactivateTunnelResponse, error)
	// TriggerTunnel is a RPC method to manually trigger a tunnel.
	TriggerTunnel(context.Context, *MsgTriggerTunnel) (*MsgTriggerTunnelResponse, error)
	// DepositToTunnel is a RPC method to deposit to an existing tunnel.
	DepositToTunnel(context.Context, *MsgDepositToTunnel) (*MsgDepositToTunnelResponse, error)
	// WithdrawFromTunnel is a RPC method to withdraw a deposit from an existing tunnel.
	WithdrawFromTunnel(context.Context, *MsgWithdrawFromTunnel) (*MsgWithdrawFromTunnelResponse, error)
	// UpdateParams is a RPC method to update parameters
	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
}

// UnimplementedMsgServer can be embedded to have forward compatible implementations.
type UnimplementedMsgServer struct {
}

func (*UnimplementedMsgServer) CreateTunnel(ctx context.Context, req *MsgCreateTunnel) (*MsgCreateTunnelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTunnel not implemented")
}
func (*UnimplementedMsgServer) UpdateRoute(ctx context.Context, req *MsgUpdateRoute) (*MsgUpdateRouteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateRoute not implemented")
}
func (*UnimplementedMsgServer) UpdateSignalsAndInterval(ctx context.Context, req *MsgUpdateSignalsAndInterval) (*MsgUpdateSignalsAndIntervalResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSignalsAndInterval not implemented")
}
func (*UnimplementedMsgServer) WithdrawFeePayerFunds(ctx context.Context, req *MsgWithdrawFeePayerFunds) (*MsgWithdrawFeePayerFundsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawFeePayerFunds not implemented")
}
func (*UnimplementedMsgServer) ActivateTunnel(ctx context.Context, req *MsgActivateTunnel) (*MsgActivateTunnelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ActivateTunnel not implemented")
}
func (*UnimplementedMsgServer) DeactivateTunnel(ctx context.Context, req *MsgDeactivateTunnel) (*MsgDeactivateTunnelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeactivateTunnel not implemented")
}
func (*UnimplementedMsgServer) TriggerTunnel(ctx context.Context, req *MsgTriggerTunnel) (*MsgTriggerTunnelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TriggerTunnel not implemented")
}
func (*UnimplementedMsgServer) DepositToTunnel(ctx context.Context, req *MsgDepositToTunnel) (*MsgDepositToTunnelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DepositToTunnel not implemented")
}
func (*UnimplementedMsgServer) WithdrawFromTunnel(ctx context.Context, req *MsgWithdrawFromTunnel) (*MsgWithdrawFromTunnelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawFromTunnel not implemented")
}
func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
}

func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
	s.RegisterService(&_Msg_serviceDesc, srv)
}

func _Msg_CreateTunnel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgCreateTunnel)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).CreateTunnel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tunnel.v1beta1.Msg/CreateTunnel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).CreateTunnel(ctx, req.(*MsgCreateTunnel))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UpdateRoute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUpdateRoute)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UpdateRoute(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tunnel.v1beta1.Msg/UpdateRoute",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UpdateRoute(ctx, req.(*MsgUpdateRoute))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UpdateSignalsAndInterval_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUpdateSignalsAndInterval)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UpdateSignalsAndInterval(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tunnel.v1beta1.Msg/UpdateSignalsAndInterval",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UpdateSignalsAndInterval(ctx, req.(*MsgUpdateSignalsAndInterval))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_WithdrawFeePayerFunds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgWithdrawFeePayerFunds)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).WithdrawFeePayerFunds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tunnel.v1beta1.Msg/WithdrawFeePayerFunds",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).WithdrawFeePayerFunds(ctx, req.(*MsgWithdrawFeePayerFunds))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_ActivateTunnel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgActivateTunnel)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).ActivateTunnel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tunnel.v1beta1.Msg/ActivateTunnel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).ActivateTunnel(ctx, req.(*MsgActivateTunnel))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_DeactivateTunnel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgDeactivateTunnel)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).DeactivateTunnel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tunnel.v1beta1.Msg/DeactivateTunnel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).DeactivateTunnel(ctx, req.(*MsgDeactivateTunnel))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_TriggerTunnel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgTriggerTunnel)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).TriggerTunnel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tunnel.v1beta1.Msg/TriggerTunnel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).TriggerTunnel(ctx, req.(*MsgTriggerTunnel))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_DepositToTunnel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgDepositToTunnel)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).DepositToTunnel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tunnel.v1beta1.Msg/DepositToTunnel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).DepositToTunnel(ctx, req.(*MsgDepositToTunnel))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_WithdrawFromTunnel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgWithdrawFromTunnel)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).WithdrawFromTunnel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tunnel.v1beta1.Msg/WithdrawFromTunnel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).WithdrawFromTunnel(ctx, req.(*MsgWithdrawFromTunnel))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUpdateParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UpdateParams(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tunnel.v1beta1.Msg/UpdateParams",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "band.tunnel.v1beta1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateTunnel",
			Handler:    _Msg_CreateTunnel_Handler,
		},
		{
			MethodName: "UpdateRoute",
			Handler:    _Msg_UpdateRoute_Handler,
		},
		{
			MethodName: "UpdateSignalsAndInterval",
			Handler:    _Msg_UpdateSignalsAndInterval_Handler,
		},
		{
			MethodName: "WithdrawFeePayerFunds",
			Handler:    _Msg_WithdrawFeePayerFunds_Handler,
		},
		{
			MethodName: "ActivateTunnel",
			Handler:    _Msg_ActivateTunnel_Handler,
		},
		{
			MethodName: "DeactivateTunnel",
			Handler:    _Msg_DeactivateTunnel_Handler,
		},
		{
			MethodName: "TriggerTunnel",
			Handler:    _Msg_TriggerTunnel_Handler,
		},
		{
			MethodName: "DepositToTunnel",
			Handler:    _Msg_DepositToTunnel_Handler,
		},
		{
			MethodName: "WithdrawFromTunnel",
			Handler:    _Msg_WithdrawFromTunnel_Handler,
		},
		{
			MethodName: "UpdateParams",
			Handler:    _Msg_UpdateParams_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "band/tunnel/v1beta1/tx.proto",
}

func (m *MsgCreateTunnel) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgCreateTunnel) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgCreateTunnel) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.InitialDeposit) > 0 {
		for iNdEx := len(m.InitialDeposit) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InitialDeposit[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Route != nil {
		{
			size, err := m.Route.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Interval != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Interval))
		i--
		dAtA[i] = 0x10
	}
	if len(m.SignalDeviations) > 0 {
		for iNdEx := len(m.SignalDeviations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SignalDeviations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *MsgCreateTunnelResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgCreateTunnelResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgCreateTunnelResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TunnelID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TunnelID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgUpdateRoute) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgUpdateRoute) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUpdateRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Route != nil {
		{
			size, err := m.Route.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.TunnelID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TunnelID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgUpdateRouteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgUpdateRouteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUpdateRouteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgUpdateSignalsAndInterval) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgUpdateSignalsAndInterval) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUpdateSignalsAndInterval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x22
	}
	if m.Interval != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Interval))
		i--
		dAtA[i] = 0x18
	}
	if len(m.SignalDeviations) > 0 {
		for iNdEx := len(m.SignalDeviations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SignalDeviations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.TunnelID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TunnelID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgUpdateSignalsAndIntervalResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgUpdateSignalsAndIntervalResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUpdateSignalsAndIntervalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgWithdrawFeePayerFunds) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgWithdrawFeePayerFunds) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgWithdrawFeePayerFunds) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Amount) > 0 {
		for iNdEx := len(m.Amount) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Amount[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.TunnelID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TunnelID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgWithdrawFeePayerFundsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgWithdrawFeePayerFundsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgWithdrawFeePayerFundsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgActivateTunnel) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgActivateTunnel) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgActivateTunnel) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x12
	}
	if m.TunnelID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TunnelID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgActivateTunnelResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgActivateTunnelResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgActivateTunnelResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgDeactivateTunnel) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgDeactivateTunnel) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgDeactivateTunnel) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x12
	}
	if m.TunnelID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TunnelID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgDeactivateTunnelResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgDeactivateTunnelResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgDeactivateTunnelResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgTriggerTunnel) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgTriggerTunnel) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgTriggerTunnel) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x12
	}
	if m.TunnelID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TunnelID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgTriggerTunnelResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgTriggerTunnelResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgTriggerTunnelResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgDepositToTunnel) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgDepositToTunnel) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgDepositToTunnel) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Depositor) > 0 {
		i -= len(m.Depositor)
		copy(dAtA[i:], m.Depositor)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Depositor)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Amount) > 0 {
		for iNdEx := len(m.Amount) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Amount[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.TunnelID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TunnelID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgDepositToTunnelResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgDepositToTunnelResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgDepositToTunnelResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgWithdrawFromTunnel) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgWithdrawFromTunnel) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgWithdrawFromTunnel) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Withdrawer) > 0 {
		i -= len(m.Withdrawer)
		copy(dAtA[i:], m.Withdrawer)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Withdrawer)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Amount) > 0 {
		for iNdEx := len(m.Amount) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Amount[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.TunnelID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TunnelID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgWithdrawFromTunnelResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgWithdrawFromTunnelResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgWithdrawFromTunnelResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgUpdateParams) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Authority) > 0 {
		i -= len(m.Authority)
		copy(dAtA[i:], m.Authority)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Authority)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgUpdateParamsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgUpdateParamsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
	offset -= sovTx(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MsgCreateTunnel) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.SignalDeviations) > 0 {
		for _, e := range m.SignalDeviations {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if m.Interval != 0 {
		n += 1 + sovTx(uint64(m.Interval))
	}
	if m.Route != nil {
		l = m.Route.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.InitialDeposit) > 0 {
		for _, e := range m.InitialDeposit {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgCreateTunnelResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TunnelID != 0 {
		n += 1 + sovTx(uint64(m.TunnelID))
	}
	return n
}

func (m *MsgUpdateRoute) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TunnelID != 0 {
		n += 1 + sovTx(uint64(m.TunnelID))
	}
	if m.Route != nil {
		l = m.Route.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgUpdateRouteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgUpdateSignalsAndInterval) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TunnelID != 0 {
		n += 1 + sovTx(uint64(m.TunnelID))
	}
	if len(m.SignalDeviations) > 0 {
		for _, e := range m.SignalDeviations {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if m.Interval != 0 {
		n += 1 + sovTx(uint64(m.Interval))
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgUpdateSignalsAndIntervalResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgWithdrawFeePayerFunds) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TunnelID != 0 {
		n += 1 + sovTx(uint64(m.TunnelID))
	}
	if len(m.Amount) > 0 {
		for _, e := range m.Amount {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgWithdrawFeePayerFundsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgActivateTunnel) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TunnelID != 0 {
		n += 1 + sovTx(uint64(m.TunnelID))
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgActivateTunnelResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgDeactivateTunnel) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TunnelID != 0 {
		n += 1 + sovTx(uint64(m.TunnelID))
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgDeactivateTunnelResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgTriggerTunnel) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TunnelID != 0 {
		n += 1 + sovTx(uint64(m.TunnelID))
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgTriggerTunnelResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgDepositToTunnel) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TunnelID != 0 {
		n += 1 + sovTx(uint64(m.TunnelID))
	}
	if len(m.Amount) > 0 {
		for _, e := range m.Amount {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	l = len(m.Depositor)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgDepositToTunnelResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgWithdrawFromTunnel) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TunnelID != 0 {
		n += 1 + sovTx(uint64(m.TunnelID))
	}
	if len(m.Amount) > 0 {
		for _, e := range m.Amount {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	l = len(m.Withdrawer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgWithdrawFromTunnelResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgUpdateParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Authority)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Params.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *MsgUpdateParamsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func sovTx(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTx(x uint64) (n int) {
	return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MsgCreateTunnel) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreateTunnel: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateTunnel: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignalDeviations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SignalDeviations = append(m.SignalDeviations, SignalDeviation{})
			if err := m.SignalDeviations[len(m.SignalDeviations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType)
			}
			m.Interval = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Interval |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Route", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Route == nil {
				m.Route = &types.Any{}
			}
			if err := m.Route.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitialDeposit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InitialDeposit = append(m.InitialDeposit, types1.Coin{})
			if err := m.InitialDeposit[len(m.InitialDeposit)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCreateTunnelResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreateTunnelResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateTunnelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TunnelID", wireType)
			}
			m.TunnelID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TunnelID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUpdateRoute) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUpdateRoute: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateRoute: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TunnelID", wireType)
			}
			m.TunnelID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TunnelID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Route", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Route == nil {
				m.Route = &types.Any{}
			}
			if err := m.Route.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUpdateRouteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUpdateRouteResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateRouteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUpdateSignalsAndInterval) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUpdateSignalsAndInterval: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateSignalsAndInterval: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TunnelID", wireType)
			}
			m.TunnelID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TunnelID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignalDeviations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SignalDeviations = append(m.SignalDeviations, SignalDeviation{})
			if err := m.SignalDeviations[len(m.SignalDeviations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType)
			}
			m.Interval = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Interval |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUpdateSignalsAndIntervalResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUpdateSignalsAndIntervalResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateSignalsAndIntervalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgWithdrawFeePayerFunds) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgWithdrawFeePayerFunds: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawFeePayerFunds: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TunnelID", wireType)
			}
			m.TunnelID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TunnelID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Amount = append(m.Amount, types1.Coin{})
			if err := m.Amount[len(m.Amount)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgWithdrawFeePayerFundsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgWithdrawFeePayerFundsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawFeePayerFundsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgActivateTunnel) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgActivateTunnel: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgActivateTunnel: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TunnelID", wireType)
			}
			m.TunnelID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TunnelID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgActivateTunnelResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgActivateTunnelResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgActivateTunnelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgDeactivateTunnel) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgDeactivateTunnel: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeactivateTunnel: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TunnelID", wireType)
			}
			m.TunnelID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TunnelID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgDeactivateTunnelResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgDeactivateTunnelResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeactivateTunnelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgTriggerTunnel) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgTriggerTunnel: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgTriggerTunnel: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TunnelID", wireType)
			}
			m.TunnelID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TunnelID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgTriggerTunnelResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgTriggerTunnelResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgTriggerTunnelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgDepositToTunnel) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgDepositToTunnel: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDepositToTunnel: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TunnelID", wireType)
			}
			m.TunnelID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TunnelID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Amount = append(m.Amount, types1.Coin{})
			if err := m.Amount[len(m.Amount)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Depositor", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Depositor = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgDepositToTunnelResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgDepositToTunnelResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDepositToTunnelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgWithdrawFromTunnel) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgWithdrawFromTunnel: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawFromTunnel: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TunnelID", wireType)
			}
			m.TunnelID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TunnelID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Amount = append(m.Amount, types1.Coin{})
			if err := m.Amount[len(m.Amount)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Withdrawer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Withdrawer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgWithdrawFromTunnelResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgWithdrawFromTunnelResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawFromTunnelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Authority = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTx(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowTx
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTx
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTx
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthTx
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTx
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTx
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
)
