msgs.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: althea/microtx/v1/msgs.proto

package types

import (
	context "context"
	fmt "fmt"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	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

// MsgMicrotx A Msg used to send funds from one Althea network wallet to another,
// via an automated device. Facilitates Liquid Infrastructure by automatically
// redirecting funds received by Liquid Infrastructure beyond configured amounts to the EVM.
// SENDER The account sending funds to receiver, must also be the signer of the
// message
// RECEIVER The account receiving funds from sender
// AMOUNTS The tokens and their quantities which should be transferred, these
// must be Cosmos coins registered as ERC20s, or the Cosmos representation of ERC20s
type MsgMicrotx struct {
	Sender   string     `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Receiver string     `protobuf:"bytes,2,opt,name=receiver,proto3" json:"receiver,omitempty"`
	Amount   types.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount"`
}

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

var xxx_messageInfo_MsgMicrotx proto.InternalMessageInfo

func (m *MsgMicrotx) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *MsgMicrotx) GetReceiver() string {
	if m != nil {
		return m.Receiver
	}
	return ""
}

func (m *MsgMicrotx) GetAmount() types.Coin {
	if m != nil {
		return m.Amount
	}
	return types.Coin{}
}

type MsgMicrotxResponse struct {
}

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

var xxx_messageInfo_MsgMicrotxResponse proto.InternalMessageInfo

// A type for the block's event log, every successful Microtx must create one of
// these in the event log
type EventMicrotx struct {
	Sender   string       `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Receiver string       `protobuf:"bytes,2,opt,name=receiver,proto3" json:"receiver,omitempty"`
	Amounts  []types.Coin `protobuf:"bytes,3,rep,name=amounts,proto3" json:"amounts"`
}

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

var xxx_messageInfo_EventMicrotx proto.InternalMessageInfo

func (m *EventMicrotx) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *EventMicrotx) GetReceiver() string {
	if m != nil {
		return m.Receiver
	}
	return ""
}

func (m *EventMicrotx) GetAmounts() []types.Coin {
	if m != nil {
		return m.Amounts
	}
	return nil
}

// A type for the block's event log, Microtx fees may be collected out-of-band and so
// this event may be emitted in an AnteHandler or during the Msg handler
type EventMicrotxFeeCollected struct {
	Sender string       `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Fee    []types.Coin `protobuf:"bytes,2,rep,name=fee,proto3" json:"fee"`
}

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

var xxx_messageInfo_EventMicrotxFeeCollected proto.InternalMessageInfo

func (m *EventMicrotxFeeCollected) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *EventMicrotxFeeCollected) GetFee() []types.Coin {
	if m != nil {
		return m.Fee
	}
	return nil
}

// A type for the block's event log recording when a Liquid Infrastructure account
// has a received balance redirected to its registered LiquidInfrastructureNFT
type EventBalanceRedirect struct {
	Account string     `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	Amount  types.Coin `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount"`
}

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

var xxx_messageInfo_EventBalanceRedirect proto.InternalMessageInfo

func (m *EventBalanceRedirect) GetAccount() string {
	if m != nil {
		return m.Account
	}
	return ""
}

func (m *EventBalanceRedirect) GetAmount() types.Coin {
	if m != nil {
		return m.Amount
	}
	return types.Coin{}
}

// Records critical information about a Liquid Infrastructure Account
// ACCOUNT The bech32 address of the liquid infrastructure account
// OWNER The bech32 address of the account now in control of the liquid infrastructure
// NFT_ADDRESS The EVM address of the token contract in control of the liquid infrastructure account's accrued profits
type LiquidInfrastructureAccount struct {
	Owner      string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
	Account    string `protobuf:"bytes,2,opt,name=account,proto3" json:"account,omitempty"`
	NftAddress string `protobuf:"bytes,3,opt,name=nft_address,json=nftAddress,proto3" json:"nft_address,omitempty"`
}

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

var xxx_messageInfo_LiquidInfrastructureAccount proto.InternalMessageInfo

func (m *LiquidInfrastructureAccount) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *LiquidInfrastructureAccount) GetAccount() string {
	if m != nil {
		return m.Account
	}
	return ""
}

func (m *LiquidInfrastructureAccount) GetNftAddress() string {
	if m != nil {
		return m.NftAddress
	}
	return ""
}

// MsgLiquify Converts the sender's account into a piece of Liquid Infrastructure,
// by creating a Non-fungible Token (NFT) within the Althea L1 EVM which will control all balances
// held by the Liquid Infrastructure Account (beyond a configurable threshold).
// The liquid infrastructure account itself will be the initial owner of the NFT,
// and must transfer control through the EVM NFT contract
// SENDER The bech32 address of the account to liquify, must also be the signer of the message
type MsgLiquify struct {
	Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
}

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

var xxx_messageInfo_MsgLiquify proto.InternalMessageInfo

func (m *MsgLiquify) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

// MsgLiquifyResponse potentially returns useful information from the liquification of an account
type MsgLiquifyResponse struct {
	Account *LiquidInfrastructureAccount `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
}

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

var xxx_messageInfo_MsgLiquifyResponse proto.InternalMessageInfo

func (m *MsgLiquifyResponse) GetAccount() *LiquidInfrastructureAccount {
	if m != nil {
		return m.Account
	}
	return nil
}

// A type for the block's event log, every successful MsgLiquify must create one of
// these in the event log
type EventAccountLiquified struct {
	Owned      string `protobuf:"bytes,1,opt,name=owned,proto3" json:"owned,omitempty"`
	NftAddress string `protobuf:"bytes,2,opt,name=nft_address,json=nftAddress,proto3" json:"nft_address,omitempty"`
}

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

var xxx_messageInfo_EventAccountLiquified proto.InternalMessageInfo

func (m *EventAccountLiquified) GetOwned() string {
	if m != nil {
		return m.Owned
	}
	return ""
}

func (m *EventAccountLiquified) GetNftAddress() string {
	if m != nil {
		return m.NftAddress
	}
	return ""
}

func init() {
	proto.RegisterType((*MsgMicrotx)(nil), "althea.microtx.v1.MsgMicrotx")
	proto.RegisterType((*MsgMicrotxResponse)(nil), "althea.microtx.v1.MsgMicrotxResponse")
	proto.RegisterType((*EventMicrotx)(nil), "althea.microtx.v1.EventMicrotx")
	proto.RegisterType((*EventMicrotxFeeCollected)(nil), "althea.microtx.v1.EventMicrotxFeeCollected")
	proto.RegisterType((*EventBalanceRedirect)(nil), "althea.microtx.v1.EventBalanceRedirect")
	proto.RegisterType((*LiquidInfrastructureAccount)(nil), "althea.microtx.v1.LiquidInfrastructureAccount")
	proto.RegisterType((*MsgLiquify)(nil), "althea.microtx.v1.MsgLiquify")
	proto.RegisterType((*MsgLiquifyResponse)(nil), "althea.microtx.v1.MsgLiquifyResponse")
	proto.RegisterType((*EventAccountLiquified)(nil), "althea.microtx.v1.EventAccountLiquified")
}

func init() { proto.RegisterFile("althea/microtx/v1/msgs.proto", fileDescriptor_07584d3779b1e62f) }

var fileDescriptor_07584d3779b1e62f = []byte{
	// 548 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x41, 0x6f, 0xd3, 0x30,
	0x14, 0xc7, 0x9b, 0x14, 0x56, 0xe6, 0x72, 0x21, 0x74, 0x28, 0x74, 0x23, 0xab, 0x22, 0x90, 0x76,
	0xc1, 0x56, 0xca, 0x01, 0x71, 0x5c, 0x27, 0x10, 0x93, 0x56, 0x0e, 0x3d, 0x72, 0x00, 0xb9, 0xce,
	0x6b, 0x66, 0x29, 0xb5, 0x4b, 0xec, 0x96, 0xf5, 0xc0, 0x85, 0x4f, 0x80, 0xc4, 0x97, 0xda, 0x71,
	0x12, 0x17, 0x4e, 0x08, 0x5a, 0x3e, 0x08, 0x6a, 0xec, 0x64, 0x6d, 0x59, 0xa7, 0x21, 0x6e, 0x7e,
	0x7e, 0x2f, 0xfe, 0xfd, 0xdf, 0xdf, 0x2f, 0x46, 0x7b, 0x34, 0xd5, 0xa7, 0x40, 0xc9, 0x90, 0xb3,
	0x4c, 0xea, 0x33, 0x32, 0x89, 0xc8, 0x50, 0x25, 0x0a, 0x8f, 0x32, 0xa9, 0xa5, 0x77, 0xcf, 0x64,
	0xb1, 0xcd, 0xe2, 0x49, 0xd4, 0x0c, 0x98, 0x54, 0x43, 0xa9, 0x48, 0x9f, 0x2a, 0x20, 0x93, 0xa8,
	0x0f, 0x9a, 0x46, 0x84, 0x49, 0x2e, 0xcc, 0x27, 0xcd, 0x46, 0x22, 0x13, 0x99, 0x2f, 0xc9, 0x62,
	0x65, 0x77, 0xf7, 0x12, 0x29, 0x93, 0x14, 0x08, 0x1d, 0x71, 0x42, 0x85, 0x90, 0x9a, 0x6a, 0x2e,
	0x85, 0xc5, 0x84, 0x53, 0x84, 0xba, 0x2a, 0xe9, 0x1a, 0x88, 0xf7, 0x00, 0x6d, 0x29, 0x10, 0x31,
	0x64, 0xbe, 0xd3, 0x72, 0x0e, 0xb6, 0x7b, 0x36, 0xf2, 0x9a, 0xe8, 0x4e, 0x06, 0x0c, 0xf8, 0x04,
	0x32, 0xdf, 0xcd, 0x33, 0x65, 0xec, 0x3d, 0x47, 0x5b, 0x74, 0x28, 0xc7, 0x42, 0xfb, 0xd5, 0x96,
	0x73, 0x50, 0x6f, 0x3f, 0xc4, 0x46, 0x26, 0x5e, 0xc8, 0xc4, 0x56, 0x26, 0x3e, 0x92, 0x5c, 0x74,
	0x6e, 0x9d, 0xff, 0xd8, 0xaf, 0xf4, 0x6c, 0x79, 0xd8, 0x40, 0xde, 0x25, 0xba, 0x07, 0x6a, 0x24,
	0x85, 0x82, 0xf0, 0x13, 0xba, 0xfb, 0x72, 0x02, 0x42, 0xff, 0x8f, 0xa4, 0x17, 0xa8, 0x66, 0x18,
	0xca, 0xaf, 0xb6, 0xaa, 0x37, 0xd1, 0x54, 0xd4, 0x87, 0x80, 0xfc, 0x65, 0xfc, 0x2b, 0x80, 0x23,
	0x99, 0xa6, 0xc0, 0x34, 0xc4, 0x1b, 0xa5, 0x44, 0xa8, 0x3a, 0x00, 0xf0, 0xdd, 0x9b, 0xa1, 0x16,
	0xb5, 0x21, 0x47, 0x8d, 0x1c, 0xd3, 0xa1, 0x29, 0x15, 0x0c, 0x7a, 0x10, 0xf3, 0x0c, 0x98, 0xf6,
	0x7c, 0x54, 0xa3, 0x8c, 0xe5, 0x6e, 0x1a, 0x46, 0x11, 0x2e, 0xd9, 0xec, 0xfe, 0x9b, 0xcd, 0x02,
	0xed, 0x9e, 0xf0, 0x0f, 0x63, 0x1e, 0x1f, 0x8b, 0x41, 0x46, 0x95, 0xce, 0xc6, 0x4c, 0x8f, 0x33,
	0x38, 0xb4, 0xe7, 0x36, 0xd0, 0x6d, 0xf9, 0x51, 0x94, 0x3d, 0x99, 0x60, 0x59, 0x87, 0xbb, 0xaa,
	0x63, 0x1f, 0xd5, 0xc5, 0x40, 0xbf, 0xa7, 0x71, 0x9c, 0x81, 0x52, 0xf9, 0x9d, 0x6f, 0xf7, 0x90,
	0x18, 0xe8, 0x43, 0xb3, 0x13, 0x3e, 0xce, 0x27, 0x2a, 0x47, 0x0e, 0xa6, 0x9b, 0x3c, 0x0b, 0xdf,
	0xe5, 0x97, 0x6f, 0xab, 0x8a, 0xcb, 0xf7, 0x5e, 0xaf, 0xb6, 0x5f, 0x6f, 0x63, 0xfc, 0xd7, 0x6f,
	0x80, 0xaf, 0xe9, 0xa6, 0x94, 0x19, 0xbe, 0x41, 0x3b, 0xb9, 0xc1, 0x36, 0x61, 0x40, 0x1c, 0xe2,
	0xa2, 0xdf, 0x78, 0xb9, 0xdf, 0x78, 0xbd, 0x2b, 0x77, 0xbd, 0xab, 0xf6, 0x2f, 0x07, 0x55, 0xbb,
	0x2a, 0xf1, 0x52, 0x54, 0x2b, 0x26, 0xf3, 0xd1, 0x15, 0xda, 0x2e, 0x07, 0xba, 0xf9, 0xe4, 0xda,
	0x74, 0x39, 0xef, 0xbb, 0x9f, 0xbf, 0xfd, 0xfe, 0xea, 0xee, 0x84, 0xf7, 0x57, 0xde, 0x01, 0x8b,
	0x48, 0x51, 0xad, 0x30, 0x72, 0x03, 0xcd, 0xa6, 0x37, 0xd1, 0xd6, 0x0c, 0xbe, 0x9a, 0x96, 0x9a,
	0xa2, 0xce, 0xf1, 0xf9, 0x2c, 0x70, 0x2e, 0x66, 0x81, 0xf3, 0x73, 0x16, 0x38, 0x5f, 0xe6, 0x41,
	0xe5, 0x62, 0x1e, 0x54, 0xbe, 0xcf, 0x83, 0xca, 0x5b, 0x92, 0x70, 0x7d, 0x3a, 0xee, 0x63, 0x26,
	0x87, 0xc4, 0x70, 0x9e, 0x0a, 0xd0, 0xc5, 0xf2, 0x24, 0x22, 0x67, 0xe5, 0x79, 0x7a, 0x3a, 0x02,
	0xd5, 0xdf, 0xca, 0x5f, 0x97, 0x67, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x45, 0x58, 0x66, 0xa7,
	0xe4, 0x04, 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 {
	// The Microtx service handles payments to Althea accounts
	Microtx(ctx context.Context, in *MsgMicrotx, opts ...grpc.CallOption) (*MsgMicrotxResponse, error)
	// The Liquify service converts an account into a piece of Liquid Infrastructure
	Liquify(ctx context.Context, in *MsgLiquify, opts ...grpc.CallOption) (*MsgLiquifyResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

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

func (c *msgClient) Microtx(ctx context.Context, in *MsgMicrotx, opts ...grpc.CallOption) (*MsgMicrotxResponse, error) {
	out := new(MsgMicrotxResponse)
	err := c.cc.Invoke(ctx, "/althea.microtx.v1.Msg/Microtx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Liquify(ctx context.Context, in *MsgLiquify, opts ...grpc.CallOption) (*MsgLiquifyResponse, error) {
	out := new(MsgLiquifyResponse)
	err := c.cc.Invoke(ctx, "/althea.microtx.v1.Msg/Liquify", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// The Microtx service handles payments to Althea accounts
	Microtx(context.Context, *MsgMicrotx) (*MsgMicrotxResponse, error)
	// The Liquify service converts an account into a piece of Liquid Infrastructure
	Liquify(context.Context, *MsgLiquify) (*MsgLiquifyResponse, error)
}

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

func (*UnimplementedMsgServer) Microtx(ctx context.Context, req *MsgMicrotx) (*MsgMicrotxResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Microtx not implemented")
}
func (*UnimplementedMsgServer) Liquify(ctx context.Context, req *MsgLiquify) (*MsgLiquifyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Liquify not implemented")
}

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

func _Msg_Microtx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgMicrotx)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).Microtx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/althea.microtx.v1.Msg/Microtx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).Microtx(ctx, req.(*MsgMicrotx))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_Liquify_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgLiquify)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).Liquify(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/althea.microtx.v1.Msg/Liquify",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).Liquify(ctx, req.(*MsgLiquify))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "althea.microtx.v1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Microtx",
			Handler:    _Msg_Microtx_Handler,
		},
		{
			MethodName: "Liquify",
			Handler:    _Msg_Liquify_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "althea/microtx/v1/msgs.proto",
}

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

func (m *MsgMicrotx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMsgs(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Receiver) > 0 {
		i -= len(m.Receiver)
		copy(dAtA[i:], m.Receiver)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Receiver)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

func (m *LiquidInfrastructureAccount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.NftAddress) > 0 {
		i -= len(m.NftAddress)
		copy(dAtA[i:], m.NftAddress)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.NftAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Account) > 0 {
		i -= len(m.Account)
		copy(dAtA[i:], m.Account)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Account)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgLiquifyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Account != nil {
		{
			size, err := m.Account.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMsgs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func encodeVarintMsgs(dAtA []byte, offset int, v uint64) int {
	offset -= sovMsgs(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MsgMicrotx) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Receiver)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovMsgs(uint64(l))
	return n
}

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

func (m *EventMicrotx) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Receiver)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	if len(m.Amounts) > 0 {
		for _, e := range m.Amounts {
			l = e.Size()
			n += 1 + l + sovMsgs(uint64(l))
		}
	}
	return n
}

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

func (m *EventBalanceRedirect) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Account)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovMsgs(uint64(l))
	return n
}

func (m *LiquidInfrastructureAccount) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Account)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.NftAddress)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

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

func (m *MsgLiquifyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Account != nil {
		l = m.Account.Size()
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *EventAccountLiquified) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Owned)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.NftAddress)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func sovMsgs(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMsgs(x uint64) (n int) {
	return sovMsgs(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MsgMicrotx) 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 ErrIntOverflowMsgs
			}
			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: MsgMicrotx: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgMicrotx: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Receiver = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgMicrotxResponse) 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 ErrIntOverflowMsgs
			}
			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: MsgMicrotxResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgMicrotxResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventMicrotx) 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 ErrIntOverflowMsgs
			}
			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: EventMicrotx: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventMicrotx: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Receiver = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amounts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Amounts = append(m.Amounts, types.Coin{})
			if err := m.Amounts[len(m.Amounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventMicrotxFeeCollected) 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 ErrIntOverflowMsgs
			}
			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: EventMicrotxFeeCollected: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventMicrotxFeeCollected: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fee = append(m.Fee, types.Coin{})
			if err := m.Fee[len(m.Fee)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBalanceRedirect) 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 ErrIntOverflowMsgs
			}
			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: EventBalanceRedirect: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventBalanceRedirect: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Account = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		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 ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LiquidInfrastructureAccount) 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 ErrIntOverflowMsgs
			}
			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: LiquidInfrastructureAccount: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LiquidInfrastructureAccount: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Account = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NftAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NftAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgLiquify) 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 ErrIntOverflowMsgs
			}
			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: MsgLiquify: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgLiquify: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgLiquifyResponse) 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 ErrIntOverflowMsgs
			}
			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: MsgLiquifyResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgLiquifyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Account == nil {
				m.Account = &LiquidInfrastructureAccount{}
			}
			if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventAccountLiquified) 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 ErrIntOverflowMsgs
			}
			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: EventAccountLiquified: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventAccountLiquified: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owned", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owned = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NftAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NftAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipMsgs(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, ErrIntOverflowMsgs
			}
			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, ErrIntOverflowMsgs
				}
				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, ErrIntOverflowMsgs
				}
				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, ErrInvalidLengthMsgs
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupMsgs
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthMsgs
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthMsgs        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMsgs          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMsgs = fmt.Errorf("proto: unexpected end of group")
)