tx.pb.go

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

package types

import (
	context "context"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	grpc1 "github.com/gogo/protobuf/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

// Grow Logic
type MsgGrowDeposit struct {
	Creator  string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	AmountIn string `protobuf:"bytes,2,opt,name=amountIn,proto3" json:"amountIn,omitempty"`
	DenomOut string `protobuf:"bytes,3,opt,name=denomOut,proto3" json:"denomOut,omitempty"`
}

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

var xxx_messageInfo_MsgGrowDeposit proto.InternalMessageInfo

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

func (m *MsgGrowDeposit) GetAmountIn() string {
	if m != nil {
		return m.AmountIn
	}
	return ""
}

func (m *MsgGrowDeposit) GetDenomOut() string {
	if m != nil {
		return m.DenomOut
	}
	return ""
}

type MsgGrowDepositResponse struct {
	Creator   string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	AmountIn  string `protobuf:"bytes,2,opt,name=amountIn,proto3" json:"amountIn,omitempty"`
	AmountOut string `protobuf:"bytes,3,opt,name=amountOut,proto3" json:"amountOut,omitempty"`
}

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

var xxx_messageInfo_MsgGrowDepositResponse proto.InternalMessageInfo

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

func (m *MsgGrowDepositResponse) GetAmountIn() string {
	if m != nil {
		return m.AmountIn
	}
	return ""
}

func (m *MsgGrowDepositResponse) GetAmountOut() string {
	if m != nil {
		return m.AmountOut
	}
	return ""
}

type MsgGrowWithdrawal struct {
	Creator  string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	AmountIn string `protobuf:"bytes,2,opt,name=amountIn,proto3" json:"amountIn,omitempty"`
}

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

var xxx_messageInfo_MsgGrowWithdrawal proto.InternalMessageInfo

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

func (m *MsgGrowWithdrawal) GetAmountIn() string {
	if m != nil {
		return m.AmountIn
	}
	return ""
}

type MsgGrowWithdrawalResponse struct {
	Creator   string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	AmountIn  string `protobuf:"bytes,2,opt,name=amountIn,proto3" json:"amountIn,omitempty"`
	AmountOut string `protobuf:"bytes,3,opt,name=amountOut,proto3" json:"amountOut,omitempty"`
}

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

var xxx_messageInfo_MsgGrowWithdrawalResponse proto.InternalMessageInfo

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

func (m *MsgGrowWithdrawalResponse) GetAmountIn() string {
	if m != nil {
		return m.AmountIn
	}
	return ""
}

func (m *MsgGrowWithdrawalResponse) GetAmountOut() string {
	if m != nil {
		return m.AmountOut
	}
	return ""
}

type MsgCreateBorrow struct {
	Borrower      string `protobuf:"bytes,1,opt,name=borrower,proto3" json:"borrower,omitempty"`
	DenomIn       string `protobuf:"bytes,2,opt,name=denomIn,proto3" json:"denomIn,omitempty"`
	DesiredAmount string `protobuf:"bytes,3,opt,name=desiredAmount,proto3" json:"desiredAmount,omitempty"`
}

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

var xxx_messageInfo_MsgCreateBorrow proto.InternalMessageInfo

func (m *MsgCreateBorrow) GetBorrower() string {
	if m != nil {
		return m.Borrower
	}
	return ""
}

func (m *MsgCreateBorrow) GetDenomIn() string {
	if m != nil {
		return m.DenomIn
	}
	return ""
}

func (m *MsgCreateBorrow) GetDesiredAmount() string {
	if m != nil {
		return m.DesiredAmount
	}
	return ""
}

type MsgCreateBorrowResponse struct {
	Borrower  string `protobuf:"bytes,1,opt,name=borrower,proto3" json:"borrower,omitempty"`
	DenomIn   string `protobuf:"bytes,2,opt,name=denomIn,proto3" json:"denomIn,omitempty"`
	AmountOut string `protobuf:"bytes,3,opt,name=amountOut,proto3" json:"amountOut,omitempty"`
	LoanId    string `protobuf:"bytes,4,opt,name=loanId,proto3" json:"loanId,omitempty"`
}

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

var xxx_messageInfo_MsgCreateBorrowResponse proto.InternalMessageInfo

func (m *MsgCreateBorrowResponse) GetBorrower() string {
	if m != nil {
		return m.Borrower
	}
	return ""
}

func (m *MsgCreateBorrowResponse) GetDenomIn() string {
	if m != nil {
		return m.DenomIn
	}
	return ""
}

func (m *MsgCreateBorrowResponse) GetAmountOut() string {
	if m != nil {
		return m.AmountOut
	}
	return ""
}

func (m *MsgCreateBorrowResponse) GetLoanId() string {
	if m != nil {
		return m.LoanId
	}
	return ""
}

type MsgDeleteBorrow struct {
	Borrower string `protobuf:"bytes,1,opt,name=borrower,proto3" json:"borrower,omitempty"`
	AmountIn string `protobuf:"bytes,2,opt,name=amountIn,proto3" json:"amountIn,omitempty"`
	DenomOut string `protobuf:"bytes,3,opt,name=denomOut,proto3" json:"denomOut,omitempty"`
}

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

var xxx_messageInfo_MsgDeleteBorrow proto.InternalMessageInfo

func (m *MsgDeleteBorrow) GetBorrower() string {
	if m != nil {
		return m.Borrower
	}
	return ""
}

func (m *MsgDeleteBorrow) GetAmountIn() string {
	if m != nil {
		return m.AmountIn
	}
	return ""
}

func (m *MsgDeleteBorrow) GetDenomOut() string {
	if m != nil {
		return m.DenomOut
	}
	return ""
}

type MsgDeleteBorrowResponse struct {
	Borrower  string `protobuf:"bytes,1,opt,name=borrower,proto3" json:"borrower,omitempty"`
	AmountOut string `protobuf:"bytes,2,opt,name=amountOut,proto3" json:"amountOut,omitempty"`
	LoanId    string `protobuf:"bytes,3,opt,name=LoanId,proto3" json:"LoanId,omitempty"`
}

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

var xxx_messageInfo_MsgDeleteBorrowResponse proto.InternalMessageInfo

func (m *MsgDeleteBorrowResponse) GetBorrower() string {
	if m != nil {
		return m.Borrower
	}
	return ""
}

func (m *MsgDeleteBorrowResponse) GetAmountOut() string {
	if m != nil {
		return m.AmountOut
	}
	return ""
}

func (m *MsgDeleteBorrowResponse) GetLoanId() string {
	if m != nil {
		return m.LoanId
	}
	return ""
}

type MsgCreateLend struct {
	Depositor string `protobuf:"bytes,1,opt,name=depositor,proto3" json:"depositor,omitempty"`
	AmountIn  string `protobuf:"bytes,2,opt,name=amountIn,proto3" json:"amountIn,omitempty"`
}

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

var xxx_messageInfo_MsgCreateLend proto.InternalMessageInfo

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

func (m *MsgCreateLend) GetAmountIn() string {
	if m != nil {
		return m.AmountIn
	}
	return ""
}

type MsgCreateLendResponse struct {
	Depositor  string `protobuf:"bytes,1,opt,name=depositor,proto3" json:"depositor,omitempty"`
	PositionId string `protobuf:"bytes,2,opt,name=positionId,proto3" json:"positionId,omitempty"`
}

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

var xxx_messageInfo_MsgCreateLendResponse proto.InternalMessageInfo

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

func (m *MsgCreateLendResponse) GetPositionId() string {
	if m != nil {
		return m.PositionId
	}
	return ""
}

type MsgWithdrawalLend struct {
	Depositor string `protobuf:"bytes,1,opt,name=depositor,proto3" json:"depositor,omitempty"`
	AmountIn  string `protobuf:"bytes,2,opt,name=amountIn,proto3" json:"amountIn,omitempty"`
	DenomOut  string `protobuf:"bytes,3,opt,name=denomOut,proto3" json:"denomOut,omitempty"`
}

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

var xxx_messageInfo_MsgWithdrawalLend proto.InternalMessageInfo

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

func (m *MsgWithdrawalLend) GetAmountIn() string {
	if m != nil {
		return m.AmountIn
	}
	return ""
}

func (m *MsgWithdrawalLend) GetDenomOut() string {
	if m != nil {
		return m.DenomOut
	}
	return ""
}

type MsgWithdrawalLendResponse struct {
	Depositor string `protobuf:"bytes,1,opt,name=depositor,proto3" json:"depositor,omitempty"`
	AmountOut string `protobuf:"bytes,2,opt,name=amountOut,proto3" json:"amountOut,omitempty"`
}

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

var xxx_messageInfo_MsgWithdrawalLendResponse proto.InternalMessageInfo

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

func (m *MsgWithdrawalLendResponse) GetAmountOut() string {
	if m != nil {
		return m.AmountOut
	}
	return ""
}

type MsgOpenLiquidationPosition struct {
	Creator  string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	AmountIn string `protobuf:"bytes,2,opt,name=amountIn,proto3" json:"amountIn,omitempty"`
	Asset    string `protobuf:"bytes,3,opt,name=asset,proto3" json:"asset,omitempty"`
	Premium  string `protobuf:"bytes,4,opt,name=premium,proto3" json:"premium,omitempty"`
}

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

var xxx_messageInfo_MsgOpenLiquidationPosition proto.InternalMessageInfo

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

func (m *MsgOpenLiquidationPosition) GetAmountIn() string {
	if m != nil {
		return m.AmountIn
	}
	return ""
}

func (m *MsgOpenLiquidationPosition) GetAsset() string {
	if m != nil {
		return m.Asset
	}
	return ""
}

func (m *MsgOpenLiquidationPosition) GetPremium() string {
	if m != nil {
		return m.Premium
	}
	return ""
}

type MsgOpenLiquidationPositionResponse struct {
	Creator              string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	LiquidatorPositionId string `protobuf:"bytes,2,opt,name=liquidatorPositionId,proto3" json:"liquidatorPositionId,omitempty"`
}

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

var xxx_messageInfo_MsgOpenLiquidationPositionResponse proto.InternalMessageInfo

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

func (m *MsgOpenLiquidationPositionResponse) GetLiquidatorPositionId() string {
	if m != nil {
		return m.LiquidatorPositionId
	}
	return ""
}

type MsgCloseLiquidationPosition struct {
	Creator              string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	LiquidatorPositionId string `protobuf:"bytes,2,opt,name=liquidatorPositionId,proto3" json:"liquidatorPositionId,omitempty"`
}

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

var xxx_messageInfo_MsgCloseLiquidationPosition proto.InternalMessageInfo

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

func (m *MsgCloseLiquidationPosition) GetLiquidatorPositionId() string {
	if m != nil {
		return m.LiquidatorPositionId
	}
	return ""
}

type MsgCloseLiquidationPositionResponse struct {
	Creator   string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	AmountOut string `protobuf:"bytes,2,opt,name=amountOut,proto3" json:"amountOut,omitempty"`
}

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

var xxx_messageInfo_MsgCloseLiquidationPositionResponse proto.InternalMessageInfo

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

func (m *MsgCloseLiquidationPositionResponse) GetAmountOut() string {
	if m != nil {
		return m.AmountOut
	}
	return ""
}

func init() {
	proto.RegisterType((*MsgGrowDeposit)(nil), "core.grow.v1beta1.MsgGrowDeposit")
	proto.RegisterType((*MsgGrowDepositResponse)(nil), "core.grow.v1beta1.MsgGrowDepositResponse")
	proto.RegisterType((*MsgGrowWithdrawal)(nil), "core.grow.v1beta1.MsgGrowWithdrawal")
	proto.RegisterType((*MsgGrowWithdrawalResponse)(nil), "core.grow.v1beta1.MsgGrowWithdrawalResponse")
	proto.RegisterType((*MsgCreateBorrow)(nil), "core.grow.v1beta1.MsgCreateBorrow")
	proto.RegisterType((*MsgCreateBorrowResponse)(nil), "core.grow.v1beta1.MsgCreateBorrowResponse")
	proto.RegisterType((*MsgDeleteBorrow)(nil), "core.grow.v1beta1.MsgDeleteBorrow")
	proto.RegisterType((*MsgDeleteBorrowResponse)(nil), "core.grow.v1beta1.MsgDeleteBorrowResponse")
	proto.RegisterType((*MsgCreateLend)(nil), "core.grow.v1beta1.MsgCreateLend")
	proto.RegisterType((*MsgCreateLendResponse)(nil), "core.grow.v1beta1.MsgCreateLendResponse")
	proto.RegisterType((*MsgWithdrawalLend)(nil), "core.grow.v1beta1.MsgWithdrawalLend")
	proto.RegisterType((*MsgWithdrawalLendResponse)(nil), "core.grow.v1beta1.MsgWithdrawalLendResponse")
	proto.RegisterType((*MsgOpenLiquidationPosition)(nil), "core.grow.v1beta1.MsgOpenLiquidationPosition")
	proto.RegisterType((*MsgOpenLiquidationPositionResponse)(nil), "core.grow.v1beta1.MsgOpenLiquidationPositionResponse")
	proto.RegisterType((*MsgCloseLiquidationPosition)(nil), "core.grow.v1beta1.MsgCloseLiquidationPosition")
	proto.RegisterType((*MsgCloseLiquidationPositionResponse)(nil), "core.grow.v1beta1.MsgCloseLiquidationPositionResponse")
}

func init() { proto.RegisterFile("core/grow/v1beta1/tx.proto", fileDescriptor_69edbfb1be74f513) }

var fileDescriptor_69edbfb1be74f513 = []byte{
	// 654 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcf, 0x6b, 0xd4, 0x4e,
	0x14, 0x6f, 0xda, 0xef, 0xb7, 0xda, 0xa7, 0xad, 0x34, 0xd4, 0x36, 0x46, 0x09, 0x75, 0xec, 0xa1,
	0x8a, 0x66, 0x69, 0x45, 0xef, 0xd6, 0x82, 0x2c, 0xec, 0xb2, 0xb5, 0x20, 0x15, 0x45, 0x21, 0xbb,
	0x19, 0xd2, 0xd0, 0x24, 0x13, 0x67, 0x12, 0xb7, 0x9e, 0x84, 0x82, 0x77, 0xff, 0x2c, 0x4f, 0xd2,
	0xa3, 0x47, 0xd9, 0xfd, 0x47, 0x24, 0x93, 0xdf, 0xdb, 0x9d, 0x6c, 0x36, 0xe2, 0x2d, 0x6f, 0xde,
	0xcb, 0xe7, 0xc7, 0xe4, 0xbd, 0x99, 0x80, 0x3a, 0x20, 0x14, 0xb7, 0x2c, 0x4a, 0x86, 0xad, 0xcf,
	0x7b, 0x7d, 0x1c, 0x18, 0x7b, 0xad, 0xe0, 0x5c, 0xf7, 0x29, 0x09, 0x88, 0xbc, 0x1e, 0xe5, 0xf4,
	0x28, 0xa7, 0x27, 0x39, 0xd4, 0x87, 0xb5, 0x2e, 0xb3, 0x5e, 0x51, 0x32, 0x3c, 0xc4, 0x3e, 0x61,
	0x76, 0x20, 0x2b, 0x70, 0x6d, 0x40, 0xb1, 0x11, 0x10, 0xaa, 0x48, 0xdb, 0xd2, 0xee, 0xca, 0x71,
	0x1a, 0xca, 0x2a, 0x5c, 0x37, 0x5c, 0x12, 0x7a, 0x41, 0xdb, 0x53, 0x16, 0x79, 0x2a, 0x8b, 0xa3,
	0x9c, 0x89, 0x3d, 0xe2, 0xf6, 0xc2, 0x40, 0x59, 0x8a, 0x73, 0x69, 0x8c, 0x1c, 0xd8, 0x2c, 0x73,
	0x1c, 0x63, 0xe6, 0x13, 0x8f, 0xe1, 0x86, 0x5c, 0xf7, 0x60, 0x25, 0x7e, 0xce, 0xc9, 0xf2, 0x05,
	0xd4, 0x86, 0xf5, 0x84, 0xed, 0xc4, 0x0e, 0x4e, 0x4d, 0x6a, 0x0c, 0x0d, 0xa7, 0x19, 0x11, 0x22,
	0x70, 0xe7, 0x0a, 0xd4, 0x3f, 0xd5, 0xee, 0xc2, 0xad, 0x2e, 0xb3, 0x5e, 0x46, 0x38, 0xf8, 0x80,
	0x50, 0x4a, 0x86, 0x11, 0x58, 0x9f, 0x3f, 0xe1, 0x94, 0x27, 0x8b, 0x23, 0x09, 0x7c, 0x93, 0x33,
	0x9e, 0x34, 0x94, 0x77, 0x60, 0xd5, 0xc4, 0xcc, 0xa6, 0xd8, 0x7c, 0xc1, 0xc1, 0x13, 0xaa, 0xf2,
	0x22, 0xfa, 0x26, 0xc1, 0xd6, 0x04, 0x5f, 0x66, 0xaf, 0x19, 0x6f, 0xa5, 0x3d, 0x79, 0x13, 0x96,
	0x1d, 0x62, 0x78, 0x6d, 0x53, 0xf9, 0x8f, 0xa7, 0x92, 0x08, 0x61, 0x6e, 0xfb, 0x10, 0x3b, 0xb8,
	0x96, 0xed, 0xa6, 0x7d, 0x78, 0xc6, 0xdd, 0x16, 0x69, 0x6a, 0xb9, 0x2d, 0x79, 0x5a, 0x9c, 0xe2,
	0xa9, 0x13, 0x7b, 0x8a, 0xe9, 0x92, 0x08, 0xb5, 0x61, 0x35, 0xdb, 0xda, 0x0e, 0xf6, 0xcc, 0x08,
	0xc6, 0x8c, 0xdb, 0x3f, 0xeb, 0x98, 0x7c, 0xa1, 0xb2, 0x0d, 0xdf, 0xc0, 0xed, 0x12, 0x54, 0xa6,
	0xba, 0x1a, 0x52, 0x03, 0xe0, 0x8f, 0x36, 0x89, 0xd4, 0xc5, 0xa0, 0x85, 0x15, 0x64, 0xf3, 0x41,
	0xc9, 0x3b, 0xfb, 0xef, 0x54, 0x56, 0xee, 0xfc, 0x09, 0x1f, 0xa4, 0x32, 0x55, 0x4d, 0x17, 0x95,
	0xbb, 0x8f, 0x2e, 0x24, 0x50, 0xbb, 0xcc, 0xea, 0xf9, 0xd8, 0xeb, 0xd8, 0x9f, 0x42, 0xdb, 0x34,
	0x22, 0x73, 0x47, 0x89, 0xc9, 0x86, 0x33, 0xba, 0x01, 0xff, 0x1b, 0x8c, 0xe1, 0xd4, 0x46, 0x1c,
	0x44, 0x58, 0x3e, 0xc5, 0xae, 0x1d, 0xba, 0x49, 0xf7, 0xa6, 0x21, 0xa2, 0x80, 0xc4, 0x1a, 0x6a,
	0x9c, 0x17, 0xfb, 0xb0, 0xe1, 0x24, 0x2f, 0x12, 0x7a, 0x34, 0xf9, 0xc9, 0xa6, 0xe6, 0xd0, 0x19,
	0xdc, 0x8d, 0x7a, 0xc2, 0x21, 0x0c, 0xcf, 0x67, 0xbc, 0x09, 0xd9, 0x07, 0x78, 0x50, 0x41, 0x56,
	0xc3, 0x61, 0xe5, 0x47, 0xdc, 0xff, 0xb9, 0x0c, 0x4b, 0x5d, 0x66, 0xc9, 0xef, 0xe1, 0x46, 0xf1,
	0x22, 0xba, 0xaf, 0x5f, 0xb9, 0xae, 0xf4, 0xf2, 0x3d, 0xa2, 0x3e, 0x9c, 0x59, 0x92, 0x89, 0x33,
	0x61, 0x6d, 0xe2, 0x4e, 0xd8, 0x11, 0xbf, 0x9c, 0x57, 0xa9, 0x8f, 0xeb, 0x54, 0x65, 0x2c, 0x6f,
	0x01, 0x0a, 0x23, 0xbf, 0x3d, 0xfd, 0xdd, 0xbc, 0x42, 0xdd, 0x9d, 0x55, 0x51, 0xd4, 0x3f, 0x31,
	0xaa, 0x02, 0xfd, 0xe5, 0x2a, 0x91, 0x7e, 0xc1, 0x2c, 0x7e, 0x84, 0x9b, 0xa5, 0xdb, 0x07, 0x55,
	0xe9, 0x8b, 0x6b, 0xd4, 0x47, 0xb3, 0x6b, 0x8a, 0xf8, 0xa5, 0x63, 0x5e, 0x80, 0x5f, 0xac, 0x11,
	0xe1, 0x4f, 0x3d, 0xc7, 0xbf, 0xc2, 0x96, 0xe8, 0x2c, 0x78, 0x32, 0x1d, 0x46, 0x50, 0xae, 0x3e,
	0x9b, 0xab, 0x3c, 0x13, 0x70, 0x21, 0x81, 0x22, 0x9c, 0x4a, 0x5d, 0xb0, 0x53, 0x82, 0x7a, 0xf5,
	0xf9, 0x7c, 0xf5, 0xa9, 0x88, 0x83, 0x83, 0x1f, 0x23, 0x4d, 0xba, 0x1c, 0x69, 0xd2, 0xef, 0x91,
	0x26, 0x7d, 0x1f, 0x6b, 0x0b, 0x97, 0x63, 0x6d, 0xe1, 0xd7, 0x58, 0x5b, 0x78, 0xb7, 0x6b, 0xd9,
	0xc1, 0x69, 0xd8, 0xd7, 0x07, 0xc4, 0x6d, 0xbd, 0x0e, 0x0d, 0x93, 0x1a, 0x01, 0xee, 0x51, 0xab,
	0xc5, 0x7f, 0x1a, 0xcf, 0xe3, 0xdf, 0xc6, 0xe0, 0x8b, 0x8f, 0x59, 0x7f, 0x99, 0xff, 0x32, 0x3e,
	0xfd, 0x13, 0x00, 0x00, 0xff, 0xff, 0xd3, 0x87, 0x68, 0x66, 0x50, 0x0a, 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 {
	GrowDeposit(ctx context.Context, in *MsgGrowDeposit, opts ...grpc.CallOption) (*MsgGrowDepositResponse, error)
	GrowWithdrawal(ctx context.Context, in *MsgGrowWithdrawal, opts ...grpc.CallOption) (*MsgGrowWithdrawalResponse, error)
	CreateLend(ctx context.Context, in *MsgCreateLend, opts ...grpc.CallOption) (*MsgCreateLendResponse, error)
	WithdrawalLend(ctx context.Context, in *MsgWithdrawalLend, opts ...grpc.CallOption) (*MsgWithdrawalLendResponse, error)
	CreateBorrow(ctx context.Context, in *MsgCreateBorrow, opts ...grpc.CallOption) (*MsgCreateBorrowResponse, error)
	DeleteBorrow(ctx context.Context, in *MsgDeleteBorrow, opts ...grpc.CallOption) (*MsgDeleteBorrowResponse, error)
	OpenLiquidationPosition(ctx context.Context, in *MsgOpenLiquidationPosition, opts ...grpc.CallOption) (*MsgOpenLiquidationPositionResponse, error)
	CloseLiquidationPosition(ctx context.Context, in *MsgCloseLiquidationPosition, opts ...grpc.CallOption) (*MsgCloseLiquidationPositionResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

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

func (c *msgClient) GrowDeposit(ctx context.Context, in *MsgGrowDeposit, opts ...grpc.CallOption) (*MsgGrowDepositResponse, error) {
	out := new(MsgGrowDepositResponse)
	err := c.cc.Invoke(ctx, "/core.grow.v1beta1.Msg/GrowDeposit", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) GrowWithdrawal(ctx context.Context, in *MsgGrowWithdrawal, opts ...grpc.CallOption) (*MsgGrowWithdrawalResponse, error) {
	out := new(MsgGrowWithdrawalResponse)
	err := c.cc.Invoke(ctx, "/core.grow.v1beta1.Msg/GrowWithdrawal", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) CreateLend(ctx context.Context, in *MsgCreateLend, opts ...grpc.CallOption) (*MsgCreateLendResponse, error) {
	out := new(MsgCreateLendResponse)
	err := c.cc.Invoke(ctx, "/core.grow.v1beta1.Msg/CreateLend", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) WithdrawalLend(ctx context.Context, in *MsgWithdrawalLend, opts ...grpc.CallOption) (*MsgWithdrawalLendResponse, error) {
	out := new(MsgWithdrawalLendResponse)
	err := c.cc.Invoke(ctx, "/core.grow.v1beta1.Msg/WithdrawalLend", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) CreateBorrow(ctx context.Context, in *MsgCreateBorrow, opts ...grpc.CallOption) (*MsgCreateBorrowResponse, error) {
	out := new(MsgCreateBorrowResponse)
	err := c.cc.Invoke(ctx, "/core.grow.v1beta1.Msg/CreateBorrow", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) DeleteBorrow(ctx context.Context, in *MsgDeleteBorrow, opts ...grpc.CallOption) (*MsgDeleteBorrowResponse, error) {
	out := new(MsgDeleteBorrowResponse)
	err := c.cc.Invoke(ctx, "/core.grow.v1beta1.Msg/DeleteBorrow", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) OpenLiquidationPosition(ctx context.Context, in *MsgOpenLiquidationPosition, opts ...grpc.CallOption) (*MsgOpenLiquidationPositionResponse, error) {
	out := new(MsgOpenLiquidationPositionResponse)
	err := c.cc.Invoke(ctx, "/core.grow.v1beta1.Msg/OpenLiquidationPosition", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) CloseLiquidationPosition(ctx context.Context, in *MsgCloseLiquidationPosition, opts ...grpc.CallOption) (*MsgCloseLiquidationPositionResponse, error) {
	out := new(MsgCloseLiquidationPositionResponse)
	err := c.cc.Invoke(ctx, "/core.grow.v1beta1.Msg/CloseLiquidationPosition", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	GrowDeposit(context.Context, *MsgGrowDeposit) (*MsgGrowDepositResponse, error)
	GrowWithdrawal(context.Context, *MsgGrowWithdrawal) (*MsgGrowWithdrawalResponse, error)
	CreateLend(context.Context, *MsgCreateLend) (*MsgCreateLendResponse, error)
	WithdrawalLend(context.Context, *MsgWithdrawalLend) (*MsgWithdrawalLendResponse, error)
	CreateBorrow(context.Context, *MsgCreateBorrow) (*MsgCreateBorrowResponse, error)
	DeleteBorrow(context.Context, *MsgDeleteBorrow) (*MsgDeleteBorrowResponse, error)
	OpenLiquidationPosition(context.Context, *MsgOpenLiquidationPosition) (*MsgOpenLiquidationPositionResponse, error)
	CloseLiquidationPosition(context.Context, *MsgCloseLiquidationPosition) (*MsgCloseLiquidationPositionResponse, error)
}

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

func (*UnimplementedMsgServer) GrowDeposit(ctx context.Context, req *MsgGrowDeposit) (*MsgGrowDepositResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GrowDeposit not implemented")
}
func (*UnimplementedMsgServer) GrowWithdrawal(ctx context.Context, req *MsgGrowWithdrawal) (*MsgGrowWithdrawalResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GrowWithdrawal not implemented")
}
func (*UnimplementedMsgServer) CreateLend(ctx context.Context, req *MsgCreateLend) (*MsgCreateLendResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateLend not implemented")
}
func (*UnimplementedMsgServer) WithdrawalLend(ctx context.Context, req *MsgWithdrawalLend) (*MsgWithdrawalLendResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawalLend not implemented")
}
func (*UnimplementedMsgServer) CreateBorrow(ctx context.Context, req *MsgCreateBorrow) (*MsgCreateBorrowResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateBorrow not implemented")
}
func (*UnimplementedMsgServer) DeleteBorrow(ctx context.Context, req *MsgDeleteBorrow) (*MsgDeleteBorrowResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteBorrow not implemented")
}
func (*UnimplementedMsgServer) OpenLiquidationPosition(ctx context.Context, req *MsgOpenLiquidationPosition) (*MsgOpenLiquidationPositionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OpenLiquidationPosition not implemented")
}
func (*UnimplementedMsgServer) CloseLiquidationPosition(ctx context.Context, req *MsgCloseLiquidationPosition) (*MsgCloseLiquidationPositionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CloseLiquidationPosition not implemented")
}

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

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

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

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

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

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

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

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

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

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "core.grow.v1beta1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GrowDeposit",
			Handler:    _Msg_GrowDeposit_Handler,
		},
		{
			MethodName: "GrowWithdrawal",
			Handler:    _Msg_GrowWithdrawal_Handler,
		},
		{
			MethodName: "CreateLend",
			Handler:    _Msg_CreateLend_Handler,
		},
		{
			MethodName: "WithdrawalLend",
			Handler:    _Msg_WithdrawalLend_Handler,
		},
		{
			MethodName: "CreateBorrow",
			Handler:    _Msg_CreateBorrow_Handler,
		},
		{
			MethodName: "DeleteBorrow",
			Handler:    _Msg_DeleteBorrow_Handler,
		},
		{
			MethodName: "OpenLiquidationPosition",
			Handler:    _Msg_OpenLiquidationPosition_Handler,
		},
		{
			MethodName: "CloseLiquidationPosition",
			Handler:    _Msg_CloseLiquidationPosition_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "core/grow/v1beta1/tx.proto",
}

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

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

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

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

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

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

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

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

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

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

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

func (m *MsgCreateBorrowResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.LoanId) > 0 {
		i -= len(m.LoanId)
		copy(dAtA[i:], m.LoanId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.LoanId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.AmountOut) > 0 {
		i -= len(m.AmountOut)
		copy(dAtA[i:], m.AmountOut)
		i = encodeVarintTx(dAtA, i, uint64(len(m.AmountOut)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.DenomIn) > 0 {
		i -= len(m.DenomIn)
		copy(dAtA[i:], m.DenomIn)
		i = encodeVarintTx(dAtA, i, uint64(len(m.DenomIn)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Borrower) > 0 {
		i -= len(m.Borrower)
		copy(dAtA[i:], m.Borrower)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Borrower)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *MsgOpenLiquidationPosition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Premium) > 0 {
		i -= len(m.Premium)
		copy(dAtA[i:], m.Premium)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Premium)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Asset) > 0 {
		i -= len(m.Asset)
		copy(dAtA[i:], m.Asset)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Asset)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.AmountIn) > 0 {
		i -= len(m.AmountIn)
		copy(dAtA[i:], m.AmountIn)
		i = encodeVarintTx(dAtA, i, uint64(len(m.AmountIn)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *MsgCloseLiquidationPositionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AmountOut) > 0 {
		i -= len(m.AmountOut)
		copy(dAtA[i:], m.AmountOut)
		i = encodeVarintTx(dAtA, i, uint64(len(m.AmountOut)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	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 *MsgGrowDeposit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.AmountIn)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.DenomOut)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

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

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

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

func (m *MsgCreateBorrowResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Borrower)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.DenomIn)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.AmountOut)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.LoanId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

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

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

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

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

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

func (m *MsgOpenLiquidationPosition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.AmountIn)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Asset)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Premium)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

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

func (m *MsgCloseLiquidationPositionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.AmountOut)
	if l > 0 {
		n += 1 + l + sovTx(uint64(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 *MsgGrowDeposit) 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: MsgGrowDeposit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgGrowDeposit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountIn", 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.AmountIn = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DenomOut", 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.DenomOut = 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 *MsgGrowDepositResponse) 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: MsgGrowDepositResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgGrowDepositResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountIn", 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.AmountIn = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountOut", 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.AmountOut = 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 *MsgGrowWithdrawal) 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: MsgGrowWithdrawal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgGrowWithdrawal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountIn", 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.AmountIn = 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 *MsgGrowWithdrawalResponse) 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: MsgGrowWithdrawalResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgGrowWithdrawalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountIn", 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.AmountIn = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountOut", 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.AmountOut = 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 *MsgCreateBorrow) 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: MsgCreateBorrow: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateBorrow: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Borrower", 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.Borrower = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DenomIn", 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.DenomIn = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DesiredAmount", 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.DesiredAmount = 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 *MsgCreateBorrowResponse) 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: MsgCreateBorrowResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateBorrowResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Borrower", 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.Borrower = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DenomIn", 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.DenomIn = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountOut", 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.AmountOut = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoanId", 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.LoanId = 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 *MsgDeleteBorrow) 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: MsgDeleteBorrow: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeleteBorrow: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Borrower", 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.Borrower = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountIn", 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.AmountIn = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DenomOut", 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.DenomOut = 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 *MsgDeleteBorrowResponse) 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: MsgDeleteBorrowResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeleteBorrowResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Borrower", 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.Borrower = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountOut", 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.AmountOut = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoanId", 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.LoanId = 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 *MsgCreateLend) 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: MsgCreateLend: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateLend: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Depositor", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Depositor = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountIn", 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.AmountIn = 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 *MsgCreateLendResponse) 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: MsgCreateLendResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateLendResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Depositor", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Depositor = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PositionId", 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.PositionId = 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 *MsgWithdrawalLend) 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: MsgWithdrawalLend: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawalLend: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Depositor", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Depositor = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountIn", 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.AmountIn = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DenomOut", 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.DenomOut = 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 *MsgWithdrawalLendResponse) 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: MsgWithdrawalLendResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawalLendResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Depositor", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Depositor = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountOut", 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.AmountOut = 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 *MsgOpenLiquidationPosition) 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: MsgOpenLiquidationPosition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgOpenLiquidationPosition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountIn", 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.AmountIn = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Asset", 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.Asset = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Premium", 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.Premium = 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 *MsgOpenLiquidationPositionResponse) 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: MsgOpenLiquidationPositionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgOpenLiquidationPositionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LiquidatorPositionId", 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.LiquidatorPositionId = 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 *MsgCloseLiquidationPosition) 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: MsgCloseLiquidationPosition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCloseLiquidationPosition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LiquidatorPositionId", 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.LiquidatorPositionId = 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 *MsgCloseLiquidationPositionResponse) 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: MsgCloseLiquidationPositionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCloseLiquidationPositionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountOut", 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.AmountOut = 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 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")
)