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

package quarantine

import (
	context "context"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "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

// MsgOptIn represents a message for opting in to account quarantine.
type MsgOptIn struct {
	ToAddress string `protobuf:"bytes,1,opt,name=to_address,json=toAddress,proto3" json:"to_address,omitempty"`
}

func (m *MsgOptIn) Reset()         { *m = MsgOptIn{} }
func (m *MsgOptIn) String() string { return proto.CompactTextString(m) }
func (*MsgOptIn) ProtoMessage()    {}
func (*MsgOptIn) Descriptor() ([]byte, []int) {
	return fileDescriptor_d2d4535ca5d9aa17, []int{0}
}
func (m *MsgOptIn) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgOptIn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgOptIn.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 *MsgOptIn) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgOptIn.Merge(m, src)
}
func (m *MsgOptIn) XXX_Size() int {
	return m.Size()
}
func (m *MsgOptIn) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgOptIn.DiscardUnknown(m)
}

var xxx_messageInfo_MsgOptIn proto.InternalMessageInfo

func (m *MsgOptIn) GetToAddress() string {
	if m != nil {
		return m.ToAddress
	}
	return ""
}

// MsgOptInResponse defines the Msg/OptIn response type.
type MsgOptInResponse struct {
}

func (m *MsgOptInResponse) Reset()         { *m = MsgOptInResponse{} }
func (m *MsgOptInResponse) String() string { return proto.CompactTextString(m) }
func (*MsgOptInResponse) ProtoMessage()    {}
func (*MsgOptInResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d2d4535ca5d9aa17, []int{1}
}
func (m *MsgOptInResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgOptInResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgOptInResponse.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 *MsgOptInResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgOptInResponse.Merge(m, src)
}
func (m *MsgOptInResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgOptInResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgOptInResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgOptInResponse proto.InternalMessageInfo

// MsgOptOut represents a message for opting in to account quarantine.
type MsgOptOut struct {
	ToAddress string `protobuf:"bytes,1,opt,name=to_address,json=toAddress,proto3" json:"to_address,omitempty"`
}

func (m *MsgOptOut) Reset()         { *m = MsgOptOut{} }
func (m *MsgOptOut) String() string { return proto.CompactTextString(m) }
func (*MsgOptOut) ProtoMessage()    {}
func (*MsgOptOut) Descriptor() ([]byte, []int) {
	return fileDescriptor_d2d4535ca5d9aa17, []int{2}
}
func (m *MsgOptOut) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgOptOut) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgOptOut.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 *MsgOptOut) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgOptOut.Merge(m, src)
}
func (m *MsgOptOut) XXX_Size() int {
	return m.Size()
}
func (m *MsgOptOut) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgOptOut.DiscardUnknown(m)
}

var xxx_messageInfo_MsgOptOut proto.InternalMessageInfo

func (m *MsgOptOut) GetToAddress() string {
	if m != nil {
		return m.ToAddress
	}
	return ""
}

// MsgOptOutResponse defines the Msg/OptOut response type.
type MsgOptOutResponse struct {
}

func (m *MsgOptOutResponse) Reset()         { *m = MsgOptOutResponse{} }
func (m *MsgOptOutResponse) String() string { return proto.CompactTextString(m) }
func (*MsgOptOutResponse) ProtoMessage()    {}
func (*MsgOptOutResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d2d4535ca5d9aa17, []int{3}
}
func (m *MsgOptOutResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgOptOutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgOptOutResponse.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 *MsgOptOutResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgOptOutResponse.Merge(m, src)
}
func (m *MsgOptOutResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgOptOutResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgOptOutResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgOptOutResponse proto.InternalMessageInfo

// MsgAccept represents a message for accepting quarantined funds.
type MsgAccept struct {
	// to_address is the address of the quarantined account that is accepting funds.
	ToAddress string `protobuf:"bytes,1,opt,name=to_address,json=toAddress,proto3" json:"to_address,omitempty"`
	// from_addresses is one or more addresses that have sent funds to the quarantined account.
	// All funds quarantined for to_address from any from_addresses are marked as accepted and released if appropriate.
	// At least one is required.
	FromAddresses []string `protobuf:"bytes,2,rep,name=from_addresses,json=fromAddresses,proto3" json:"from_addresses,omitempty"`
	// permanent, if true, sets up auto-accept for the to_address from each from_address.
	// If false (default), only the currently quarantined funds will be accepted.
	Permanent bool `protobuf:"varint,3,opt,name=permanent,proto3" json:"permanent,omitempty"`
}

func (m *MsgAccept) Reset()         { *m = MsgAccept{} }
func (m *MsgAccept) String() string { return proto.CompactTextString(m) }
func (*MsgAccept) ProtoMessage()    {}
func (*MsgAccept) Descriptor() ([]byte, []int) {
	return fileDescriptor_d2d4535ca5d9aa17, []int{4}
}
func (m *MsgAccept) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgAccept) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgAccept.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 *MsgAccept) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgAccept.Merge(m, src)
}
func (m *MsgAccept) XXX_Size() int {
	return m.Size()
}
func (m *MsgAccept) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgAccept.DiscardUnknown(m)
}

var xxx_messageInfo_MsgAccept proto.InternalMessageInfo

func (m *MsgAccept) GetToAddress() string {
	if m != nil {
		return m.ToAddress
	}
	return ""
}

func (m *MsgAccept) GetFromAddresses() []string {
	if m != nil {
		return m.FromAddresses
	}
	return nil
}

func (m *MsgAccept) GetPermanent() bool {
	if m != nil {
		return m.Permanent
	}
	return false
}

// MsgAcceptResponse defines the Msg/Accept response type.
type MsgAcceptResponse struct {
	// funds_released is the amount that was quarantined but has now been released and sent to the requester.
	FundsReleased github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=funds_released,json=fundsReleased,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"funds_released"`
}

func (m *MsgAcceptResponse) Reset()         { *m = MsgAcceptResponse{} }
func (m *MsgAcceptResponse) String() string { return proto.CompactTextString(m) }
func (*MsgAcceptResponse) ProtoMessage()    {}
func (*MsgAcceptResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d2d4535ca5d9aa17, []int{5}
}
func (m *MsgAcceptResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgAcceptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgAcceptResponse.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 *MsgAcceptResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgAcceptResponse.Merge(m, src)
}
func (m *MsgAcceptResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgAcceptResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgAcceptResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgAcceptResponse proto.InternalMessageInfo

func (m *MsgAcceptResponse) GetFundsReleased() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.FundsReleased
	}
	return nil
}

// MsgDecline represents a message for declining quarantined funds.
type MsgDecline struct {
	// to_address is the address of the quarantined account that is accepting funds.
	ToAddress string `protobuf:"bytes,1,opt,name=to_address,json=toAddress,proto3" json:"to_address,omitempty"`
	// from_addresses is one or more addresses that have sent funds to the quarantined account.
	// All funds quarantined for to_address from any from_addresses are marked as declined.
	// At least one is required.
	FromAddresses []string `protobuf:"bytes,2,rep,name=from_addresses,json=fromAddresses,proto3" json:"from_addresses,omitempty"`
	// permanent, if true, sets up auto-decline for the to_address from each from_address.
	// If false (default), only the currently quarantined funds will be declined.
	Permanent bool `protobuf:"varint,3,opt,name=permanent,proto3" json:"permanent,omitempty"`
}

func (m *MsgDecline) Reset()         { *m = MsgDecline{} }
func (m *MsgDecline) String() string { return proto.CompactTextString(m) }
func (*MsgDecline) ProtoMessage()    {}
func (*MsgDecline) Descriptor() ([]byte, []int) {
	return fileDescriptor_d2d4535ca5d9aa17, []int{6}
}
func (m *MsgDecline) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgDecline) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgDecline.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 *MsgDecline) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgDecline.Merge(m, src)
}
func (m *MsgDecline) XXX_Size() int {
	return m.Size()
}
func (m *MsgDecline) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgDecline.DiscardUnknown(m)
}

var xxx_messageInfo_MsgDecline proto.InternalMessageInfo

func (m *MsgDecline) GetToAddress() string {
	if m != nil {
		return m.ToAddress
	}
	return ""
}

func (m *MsgDecline) GetFromAddresses() []string {
	if m != nil {
		return m.FromAddresses
	}
	return nil
}

func (m *MsgDecline) GetPermanent() bool {
	if m != nil {
		return m.Permanent
	}
	return false
}

// MsgDeclineResponse defines the Msg/Decline response type.
type MsgDeclineResponse struct {
}

func (m *MsgDeclineResponse) Reset()         { *m = MsgDeclineResponse{} }
func (m *MsgDeclineResponse) String() string { return proto.CompactTextString(m) }
func (*MsgDeclineResponse) ProtoMessage()    {}
func (*MsgDeclineResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d2d4535ca5d9aa17, []int{7}
}
func (m *MsgDeclineResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgDeclineResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgDeclineResponse.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 *MsgDeclineResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgDeclineResponse.Merge(m, src)
}
func (m *MsgDeclineResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgDeclineResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgDeclineResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgDeclineResponse proto.InternalMessageInfo

// MsgUpdateAutoResponses represents a message for updating quarantine auto-responses for a receiving address.
type MsgUpdateAutoResponses struct {
	// to_address is the quarantined address that would be accepting or declining funds.
	ToAddress string `protobuf:"bytes,1,opt,name=to_address,json=toAddress,proto3" json:"to_address,omitempty"`
	// updates is the list of addresses and auto-responses that should be updated for the to_address.
	Updates []*AutoResponseUpdate `protobuf:"bytes,2,rep,name=updates,proto3" json:"updates,omitempty"`
}

func (m *MsgUpdateAutoResponses) Reset()         { *m = MsgUpdateAutoResponses{} }
func (m *MsgUpdateAutoResponses) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateAutoResponses) ProtoMessage()    {}
func (*MsgUpdateAutoResponses) Descriptor() ([]byte, []int) {
	return fileDescriptor_d2d4535ca5d9aa17, []int{8}
}
func (m *MsgUpdateAutoResponses) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUpdateAutoResponses) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUpdateAutoResponses.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 *MsgUpdateAutoResponses) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUpdateAutoResponses.Merge(m, src)
}
func (m *MsgUpdateAutoResponses) XXX_Size() int {
	return m.Size()
}
func (m *MsgUpdateAutoResponses) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUpdateAutoResponses.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateAutoResponses proto.InternalMessageInfo

func (m *MsgUpdateAutoResponses) GetToAddress() string {
	if m != nil {
		return m.ToAddress
	}
	return ""
}

func (m *MsgUpdateAutoResponses) GetUpdates() []*AutoResponseUpdate {
	if m != nil {
		return m.Updates
	}
	return nil
}

// MsgUpdateAutoResponsesResponse defines the Msg/UpdateAutoResponse response type.
type MsgUpdateAutoResponsesResponse struct {
}

func (m *MsgUpdateAutoResponsesResponse) Reset()         { *m = MsgUpdateAutoResponsesResponse{} }
func (m *MsgUpdateAutoResponsesResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateAutoResponsesResponse) ProtoMessage()    {}
func (*MsgUpdateAutoResponsesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d2d4535ca5d9aa17, []int{9}
}
func (m *MsgUpdateAutoResponsesResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUpdateAutoResponsesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUpdateAutoResponsesResponse.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 *MsgUpdateAutoResponsesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUpdateAutoResponsesResponse.Merge(m, src)
}
func (m *MsgUpdateAutoResponsesResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgUpdateAutoResponsesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUpdateAutoResponsesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUpdateAutoResponsesResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgOptIn)(nil), "cosmos.quarantine.v1beta1.MsgOptIn")
	proto.RegisterType((*MsgOptInResponse)(nil), "cosmos.quarantine.v1beta1.MsgOptInResponse")
	proto.RegisterType((*MsgOptOut)(nil), "cosmos.quarantine.v1beta1.MsgOptOut")
	proto.RegisterType((*MsgOptOutResponse)(nil), "cosmos.quarantine.v1beta1.MsgOptOutResponse")
	proto.RegisterType((*MsgAccept)(nil), "cosmos.quarantine.v1beta1.MsgAccept")
	proto.RegisterType((*MsgAcceptResponse)(nil), "cosmos.quarantine.v1beta1.MsgAcceptResponse")
	proto.RegisterType((*MsgDecline)(nil), "cosmos.quarantine.v1beta1.MsgDecline")
	proto.RegisterType((*MsgDeclineResponse)(nil), "cosmos.quarantine.v1beta1.MsgDeclineResponse")
	proto.RegisterType((*MsgUpdateAutoResponses)(nil), "cosmos.quarantine.v1beta1.MsgUpdateAutoResponses")
	proto.RegisterType((*MsgUpdateAutoResponsesResponse)(nil), "cosmos.quarantine.v1beta1.MsgUpdateAutoResponsesResponse")
}

func init() {
	proto.RegisterFile("cosmos/quarantine/v1beta1/tx.proto", fileDescriptor_d2d4535ca5d9aa17)
}

var fileDescriptor_d2d4535ca5d9aa17 = []byte{
	// 640 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x55, 0xbf, 0x6f, 0xd3, 0x4e,
	0x14, 0xcf, 0x35, 0xdf, 0x6f, 0xdb, 0x5c, 0x69, 0xa1, 0x6e, 0x05, 0xa9, 0x85, 0xdc, 0x28, 0x80,
	0x14, 0x05, 0x62, 0x93, 0x32, 0x20, 0x58, 0x50, 0x0a, 0x02, 0x81, 0x14, 0x55, 0x32, 0x74, 0x61,
	0x20, 0xba, 0xd8, 0x57, 0x63, 0x51, 0xdf, 0x19, 0xdf, 0xb9, 0x6a, 0x37, 0xc4, 0x94, 0x91, 0x99,
	0x81, 0x11, 0x21, 0x58, 0x3a, 0x94, 0xff, 0xa1, 0x63, 0xc5, 0xc4, 0x04, 0x28, 0x19, 0xf2, 0x6f,
	0x20, 0xfb, 0xce, 0x89, 0xa3, 0xa4, 0x49, 0xa8, 0x58, 0x58, 0xfc, 0xe3, 0xbd, 0xcf, 0xe7, 0x7d,
	0x3e, 0xcf, 0x7a, 0xcf, 0x07, 0x8b, 0x16, 0x65, 0x1e, 0x65, 0xc6, 0xeb, 0x10, 0x05, 0x88, 0x70,
	0x97, 0x60, 0x63, 0xaf, 0xda, 0xc4, 0x1c, 0x55, 0x0d, 0xbe, 0xaf, 0xfb, 0x01, 0xe5, 0x54, 0x59,
	0x13, 0x18, 0xbd, 0x8f, 0xd1, 0x25, 0x46, 0x5d, 0x46, 0x9e, 0x4b, 0xa8, 0x11, 0x5f, 0x05, 0x5a,
	0xd5, 0x64, 0xc5, 0x26, 0x62, 0xfd, 0x5a, 0x16, 0x75, 0x89, 0xcc, 0x5f, 0x92, 0x79, 0x8f, 0x39,
	0xc6, 0x5e, 0x35, 0xba, 0xc9, 0x44, 0xf9, 0x74, 0x2b, 0x29, 0x65, 0x81, 0x95, 0x96, 0x1a, 0xf1,
	0x9b, 0x21, 0xfd, 0x89, 0xd4, 0xaa, 0x43, 0x1d, 0x2a, 0xe2, 0xd1, 0x93, 0x88, 0x16, 0x9f, 0xc1,
	0xf9, 0x3a, 0x73, 0xb6, 0x7c, 0xfe, 0x98, 0x28, 0xb7, 0x21, 0xe4, 0xb4, 0x81, 0x6c, 0x3b, 0xc0,
	0x8c, 0xe5, 0x41, 0x01, 0x94, 0x72, 0x9b, 0xf9, 0x6f, 0x47, 0x95, 0x55, 0x59, 0xa7, 0x26, 0x32,
	0x4f, 0x79, 0xe0, 0x12, 0xc7, 0xcc, 0x71, 0x2a, 0x03, 0x77, 0xcf, 0xbf, 0xed, 0x1e, 0x96, 0x53,
	0xdc, 0xa2, 0x02, 0x2f, 0x24, 0x55, 0x4d, 0xcc, 0x7c, 0x4a, 0x18, 0x2e, 0x6e, 0xc3, 0x9c, 0x88,
	0x6d, 0x85, 0xfc, 0x2f, 0x4a, 0xad, 0xc0, 0xe5, 0x5e, 0xd9, 0x9e, 0xd6, 0x11, 0x88, 0xc5, 0x6a,
	0x96, 0x85, 0xfd, 0xb3, 0x8b, 0x29, 0xf7, 0xe0, 0xd2, 0x4e, 0x40, 0xbd, 0x84, 0x8a, 0x59, 0x7e,
	0xa6, 0x90, 0x1d, 0x4b, 0x5e, 0x8c, 0xf0, 0xb5, 0x04, 0xae, 0x5c, 0x86, 0x39, 0x1f, 0x07, 0x1e,
	0x22, 0x98, 0xf0, 0x7c, 0xb6, 0x00, 0x4a, 0xf3, 0x66, 0x3f, 0x30, 0xdc, 0xcb, 0x07, 0x10, 0x37,
	0x23, 0x6c, 0x27, 0xcd, 0x28, 0x2d, 0x00, 0x97, 0x76, 0x42, 0x62, 0xb3, 0x46, 0x80, 0x77, 0x31,
	0x62, 0xd8, 0xce, 0x83, 0x42, 0xb6, 0xb4, 0xb0, 0xb1, 0xa6, 0x4b, 0x0f, 0xd1, 0x48, 0x25, 0xa3,
	0xa7, 0xdf, 0xa7, 0x2e, 0xd9, 0x7c, 0x78, 0xfc, 0x63, 0x3d, 0xf3, 0xf9, 0xe7, 0x7a, 0xc9, 0x71,
	0xf9, 0xcb, 0xb0, 0xa9, 0x5b, 0xd4, 0x93, 0xd3, 0x20, 0x6f, 0x15, 0x66, 0xbf, 0x32, 0xf8, 0x81,
	0x8f, 0x59, 0x4c, 0x60, 0xef, 0xbb, 0x87, 0xe5, 0x73, 0xbb, 0xd8, 0x41, 0xd6, 0x41, 0x23, 0x1a,
	0x4a, 0xf6, 0xa9, 0x7b, 0x58, 0x06, 0xe6, 0x62, 0x2c, 0x6c, 0x4a, 0xdd, 0xe2, 0x57, 0x00, 0x61,
	0x9d, 0x39, 0x0f, 0xb0, 0xb5, 0xeb, 0x12, 0xfc, 0xef, 0x7c, 0xd8, 0x55, 0xa8, 0xf4, 0x6d, 0xf7,
	0xa6, 0xe4, 0x0b, 0x80, 0x17, 0xeb, 0xcc, 0xd9, 0xf6, 0x6d, 0xc4, 0x71, 0x2d, 0xe4, 0x34, 0xc9,
	0xb0, 0xb3, 0x77, 0xf6, 0x08, 0xce, 0x85, 0x71, 0x3d, 0xd1, 0xd2, 0xc2, 0x46, 0x45, 0x3f, 0xf5,
	0x2f, 0xa1, 0xa7, 0x35, 0x85, 0x0b, 0x33, 0x61, 0x0f, 0xf7, 0x50, 0x80, 0xda, 0x68, 0xb3, 0xc9,
	0xc3, 0xc6, 0xc7, 0xff, 0x60, 0xb6, 0xce, 0x1c, 0xe5, 0x05, 0xfc, 0x5f, 0x2c, 0xf4, 0x95, 0x31,
	0xda, 0xc9, 0x7e, 0xaa, 0xd7, 0xa7, 0x00, 0xf5, 0x3e, 0x59, 0xb6, 0x35, 0x03, 0x14, 0x04, 0x67,
	0xe5, 0x1a, 0x5f, 0x9d, 0xc8, 0xdd, 0x0a, 0xb9, 0x7a, 0x63, 0x1a, 0xd4, 0x90, 0x84, 0x5c, 0xde,
	0x09, 0x12, 0x02, 0x35, 0x49, 0x62, 0x70, 0xa3, 0x84, 0x84, 0x0d, 0xe7, 0x92, 0x39, 0xbe, 0x36,
	0x9e, 0x2d, 0x61, 0x6a, 0x65, 0x2a, 0xd8, 0xa0, 0x4a, 0x0b, 0xc0, 0x95, 0x51, 0x03, 0x56, 0x1d,
	0x5f, 0x6b, 0x04, 0x45, 0xbd, 0xf3, 0xc7, 0x94, 0x01, 0x2b, 0xea, 0xfc, 0x9b, 0x68, 0xa5, 0x5b,
	0x33, 0x60, 0xf3, 0xc9, 0x71, 0x5b, 0x03, 0x27, 0x6d, 0x0d, 0xfc, 0x6a, 0x6b, 0xe0, 0x5d, 0x47,
	0xcb, 0x9c, 0x74, 0xb4, 0xcc, 0xf7, 0x8e, 0x96, 0x79, 0x7e, 0x33, 0xf5, 0xbf, 0xf0, 0x03, 0xba,
	0x87, 0x09, 0x22, 0x16, 0xae, 0xb8, 0x34, 0xf5, 0x66, 0xec, 0xa7, 0xce, 0x9d, 0xe6, 0x6c, 0x7c,
	0x8e, 0xdc, 0xfa, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x95, 0x8e, 0x6d, 0x3c, 0x31, 0x07, 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.
//
// Deprecated: Do not use.
type MsgClient interface {
	// Deprecated: The quarantine module has been removed.
	OptIn(ctx context.Context, in *MsgOptIn, opts ...grpc.CallOption) (*MsgOptInResponse, error)
	// Deprecated: The quarantine module has been removed.
	OptOut(ctx context.Context, in *MsgOptOut, opts ...grpc.CallOption) (*MsgOptOutResponse, error)
	// Deprecated: The quarantine module has been removed.
	Accept(ctx context.Context, in *MsgAccept, opts ...grpc.CallOption) (*MsgAcceptResponse, error)
	// Deprecated: The quarantine module has been removed.
	Decline(ctx context.Context, in *MsgDecline, opts ...grpc.CallOption) (*MsgDeclineResponse, error)
	// Deprecated: The quarantine module has been removed.
	UpdateAutoResponses(ctx context.Context, in *MsgUpdateAutoResponses, opts ...grpc.CallOption) (*MsgUpdateAutoResponsesResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

// Deprecated: Do not use.
func NewMsgClient(cc grpc1.ClientConn) MsgClient {
	return &msgClient{cc}
}

// Deprecated: Do not use.
func (c *msgClient) OptIn(ctx context.Context, in *MsgOptIn, opts ...grpc.CallOption) (*MsgOptInResponse, error) {
	out := new(MsgOptInResponse)
	err := c.cc.Invoke(ctx, "/cosmos.quarantine.v1beta1.Msg/OptIn", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Deprecated: Do not use.
func (c *msgClient) OptOut(ctx context.Context, in *MsgOptOut, opts ...grpc.CallOption) (*MsgOptOutResponse, error) {
	out := new(MsgOptOutResponse)
	err := c.cc.Invoke(ctx, "/cosmos.quarantine.v1beta1.Msg/OptOut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Deprecated: Do not use.
func (c *msgClient) Accept(ctx context.Context, in *MsgAccept, opts ...grpc.CallOption) (*MsgAcceptResponse, error) {
	out := new(MsgAcceptResponse)
	err := c.cc.Invoke(ctx, "/cosmos.quarantine.v1beta1.Msg/Accept", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Deprecated: Do not use.
func (c *msgClient) Decline(ctx context.Context, in *MsgDecline, opts ...grpc.CallOption) (*MsgDeclineResponse, error) {
	out := new(MsgDeclineResponse)
	err := c.cc.Invoke(ctx, "/cosmos.quarantine.v1beta1.Msg/Decline", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Deprecated: Do not use.
func (c *msgClient) UpdateAutoResponses(ctx context.Context, in *MsgUpdateAutoResponses, opts ...grpc.CallOption) (*MsgUpdateAutoResponsesResponse, error) {
	out := new(MsgUpdateAutoResponsesResponse)
	err := c.cc.Invoke(ctx, "/cosmos.quarantine.v1beta1.Msg/UpdateAutoResponses", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
//
// Deprecated: Do not use.
type MsgServer interface {
	// Deprecated: The quarantine module has been removed.
	OptIn(context.Context, *MsgOptIn) (*MsgOptInResponse, error)
	// Deprecated: The quarantine module has been removed.
	OptOut(context.Context, *MsgOptOut) (*MsgOptOutResponse, error)
	// Deprecated: The quarantine module has been removed.
	Accept(context.Context, *MsgAccept) (*MsgAcceptResponse, error)
	// Deprecated: The quarantine module has been removed.
	Decline(context.Context, *MsgDecline) (*MsgDeclineResponse, error)
	// Deprecated: The quarantine module has been removed.
	UpdateAutoResponses(context.Context, *MsgUpdateAutoResponses) (*MsgUpdateAutoResponsesResponse, error)
}

// Deprecated: Do not use.
// UnimplementedMsgServer can be embedded to have forward compatible implementations.
type UnimplementedMsgServer struct {
}

func (*UnimplementedMsgServer) OptIn(ctx context.Context, req *MsgOptIn) (*MsgOptInResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OptIn not implemented")
}
func (*UnimplementedMsgServer) OptOut(ctx context.Context, req *MsgOptOut) (*MsgOptOutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OptOut not implemented")
}
func (*UnimplementedMsgServer) Accept(ctx context.Context, req *MsgAccept) (*MsgAcceptResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Accept not implemented")
}
func (*UnimplementedMsgServer) Decline(ctx context.Context, req *MsgDecline) (*MsgDeclineResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Decline not implemented")
}
func (*UnimplementedMsgServer) UpdateAutoResponses(ctx context.Context, req *MsgUpdateAutoResponses) (*MsgUpdateAutoResponsesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateAutoResponses not implemented")
}

// Deprecated: Do not use.
func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
	s.RegisterService(&_Msg_serviceDesc, srv)
}

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

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

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

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

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

var Msg_serviceDesc = _Msg_serviceDesc
var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "cosmos.quarantine.v1beta1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "OptIn",
			Handler:    _Msg_OptIn_Handler,
		},
		{
			MethodName: "OptOut",
			Handler:    _Msg_OptOut_Handler,
		},
		{
			MethodName: "Accept",
			Handler:    _Msg_Accept_Handler,
		},
		{
			MethodName: "Decline",
			Handler:    _Msg_Decline_Handler,
		},
		{
			MethodName: "UpdateAutoResponses",
			Handler:    _Msg_UpdateAutoResponses_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "cosmos/quarantine/v1beta1/tx.proto",
}

func (m *MsgOptIn) 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 *MsgOptIn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgOptIn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ToAddress) > 0 {
		i -= len(m.ToAddress)
		copy(dAtA[i:], m.ToAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ToAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgOptInResponse) 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 *MsgOptInResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *MsgOptOut) 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 *MsgOptOut) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgOptOut) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ToAddress) > 0 {
		i -= len(m.ToAddress)
		copy(dAtA[i:], m.ToAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ToAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgOptOutResponse) 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 *MsgOptOutResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *MsgAccept) 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 *MsgAccept) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgAccept) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Permanent {
		i--
		if m.Permanent {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.FromAddresses) > 0 {
		for iNdEx := len(m.FromAddresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.FromAddresses[iNdEx])
			copy(dAtA[i:], m.FromAddresses[iNdEx])
			i = encodeVarintTx(dAtA, i, uint64(len(m.FromAddresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ToAddress) > 0 {
		i -= len(m.ToAddress)
		copy(dAtA[i:], m.ToAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ToAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgAcceptResponse) 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 *MsgAcceptResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgAcceptResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.FundsReleased) > 0 {
		for iNdEx := len(m.FundsReleased) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FundsReleased[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 *MsgDecline) 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 *MsgDecline) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgDecline) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Permanent {
		i--
		if m.Permanent {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.FromAddresses) > 0 {
		for iNdEx := len(m.FromAddresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.FromAddresses[iNdEx])
			copy(dAtA[i:], m.FromAddresses[iNdEx])
			i = encodeVarintTx(dAtA, i, uint64(len(m.FromAddresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ToAddress) > 0 {
		i -= len(m.ToAddress)
		copy(dAtA[i:], m.ToAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ToAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgDeclineResponse) 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 *MsgDeclineResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *MsgUpdateAutoResponses) 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 *MsgUpdateAutoResponses) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *MsgUpdateAutoResponsesResponse) 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 *MsgUpdateAutoResponsesResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUpdateAutoResponsesResponse) 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 *MsgOptIn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ToAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

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

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

func (m *MsgAccept) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ToAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.FromAddresses) > 0 {
		for _, s := range m.FromAddresses {
			l = len(s)
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if m.Permanent {
		n += 2
	}
	return n
}

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

func (m *MsgDecline) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ToAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.FromAddresses) > 0 {
		for _, s := range m.FromAddresses {
			l = len(s)
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if m.Permanent {
		n += 2
	}
	return n
}

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

func (m *MsgUpdateAutoResponses) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ToAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Updates) > 0 {
		for _, e := range m.Updates {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	return n
}

func (m *MsgUpdateAutoResponsesResponse) 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 *MsgOptIn) 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: MsgOptIn: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgOptIn: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", 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.ToAddress = 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 *MsgOptInResponse) 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: MsgOptInResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgOptInResponse: 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 *MsgOptOut) 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: MsgOptOut: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgOptOut: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", 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.ToAddress = 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 *MsgOptOutResponse) 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: MsgOptOutResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgOptOutResponse: 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 *MsgAccept) 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: MsgAccept: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAccept: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", 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.ToAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromAddresses", 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.FromAddresses = append(m.FromAddresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Permanent", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Permanent = bool(v != 0)
		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 *MsgAcceptResponse) 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: MsgAcceptResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAcceptResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FundsReleased", 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.FundsReleased = append(m.FundsReleased, types.Coin{})
			if err := m.FundsReleased[len(m.FundsReleased)-1].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 *MsgDecline) 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: MsgDecline: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDecline: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", 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.ToAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromAddresses", 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.FromAddresses = append(m.FromAddresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Permanent", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Permanent = bool(v != 0)
		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 *MsgDeclineResponse) 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: MsgDeclineResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeclineResponse: 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 *MsgUpdateAutoResponses) 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: MsgUpdateAutoResponses: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateAutoResponses: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", 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.ToAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Updates", 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.Updates = append(m.Updates, &AutoResponseUpdate{})
			if err := m.Updates[len(m.Updates)-1].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 *MsgUpdateAutoResponsesResponse) 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: MsgUpdateAutoResponsesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateAutoResponsesResponse: 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")
)
