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

var xxx_messageInfo_MsgDeposit proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_MsgDepositResponse proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_MsgWithdrawal proto.InternalMessageInfo

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

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

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

var xxx_messageInfo_MsgWithdrawalResponse proto.InternalMessageInfo

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

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

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

type MsgCreateLend 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 *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{4}
}
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) GetBorrower() string {
	if m != nil {
		return m.Borrower
	}
	return ""
}

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

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

type MsgCreateLendResponse 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 *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{5}
}
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) GetBorrower() string {
	if m != nil {
		return m.Borrower
	}
	return ""
}

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

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

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

type MsgDeleteLend 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"`
	LoanId   string `protobuf:"bytes,3,opt,name=LoanId,proto3" json:"LoanId,omitempty"`
	DenomOut string `protobuf:"bytes,4,opt,name=denomOut,proto3" json:"denomOut,omitempty"`
}

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

var xxx_messageInfo_MsgDeleteLend proto.InternalMessageInfo

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

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

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

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

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

var xxx_messageInfo_MsgDeleteLendResponse proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_MsgDepositCollateral proto.InternalMessageInfo

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

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

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

var xxx_messageInfo_MsgDepositCollateralResponse proto.InternalMessageInfo

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

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

type MsgWithdrawalCollateral struct {
	Depositor string `protobuf:"bytes,1,opt,name=depositor,proto3" json:"depositor,omitempty"`
	Denom     string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"`
}

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

var xxx_messageInfo_MsgWithdrawalCollateral proto.InternalMessageInfo

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

func (m *MsgWithdrawalCollateral) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

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

var xxx_messageInfo_MsgWithdrawalCollateralResponse proto.InternalMessageInfo

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

func (m *MsgWithdrawalCollateralResponse) 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((*MsgDeposit)(nil), "core.grow.v1beta1.MsgDeposit")
	proto.RegisterType((*MsgDepositResponse)(nil), "core.grow.v1beta1.MsgDepositResponse")
	proto.RegisterType((*MsgWithdrawal)(nil), "core.grow.v1beta1.MsgWithdrawal")
	proto.RegisterType((*MsgWithdrawalResponse)(nil), "core.grow.v1beta1.MsgWithdrawalResponse")
	proto.RegisterType((*MsgCreateLend)(nil), "core.grow.v1beta1.MsgCreateLend")
	proto.RegisterType((*MsgCreateLendResponse)(nil), "core.grow.v1beta1.MsgCreateLendResponse")
	proto.RegisterType((*MsgDeleteLend)(nil), "core.grow.v1beta1.MsgDeleteLend")
	proto.RegisterType((*MsgDeleteLendResponse)(nil), "core.grow.v1beta1.MsgDeleteLendResponse")
	proto.RegisterType((*MsgDepositCollateral)(nil), "core.grow.v1beta1.MsgDepositCollateral")
	proto.RegisterType((*MsgDepositCollateralResponse)(nil), "core.grow.v1beta1.MsgDepositCollateralResponse")
	proto.RegisterType((*MsgWithdrawalCollateral)(nil), "core.grow.v1beta1.MsgWithdrawalCollateral")
	proto.RegisterType((*MsgWithdrawalCollateralResponse)(nil), "core.grow.v1beta1.MsgWithdrawalCollateralResponse")
	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{
	// 671 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcf, 0x4f, 0xd4, 0x4e,
	0x14, 0xa7, 0xfc, 0x58, 0xbe, 0xbc, 0x84, 0x03, 0xcd, 0x7e, 0xa1, 0xa9, 0x58, 0xc9, 0xa8, 0x91,
	0x98, 0xd8, 0x06, 0x8c, 0xde, 0x05, 0x3c, 0x90, 0xb0, 0x59, 0xe4, 0x22, 0x31, 0x62, 0x32, 0x4b,
	0x27, 0xa5, 0xa1, 0xed, 0xd4, 0x99, 0x29, 0x60, 0x3c, 0x98, 0xe0, 0x3f, 0xe0, 0x9f, 0xe5, 0x11,
	0x6f, 0x1e, 0xcd, 0xee, 0x3f, 0x62, 0x3a, 0xfd, 0xb9, 0xd0, 0x96, 0xee, 0x26, 0xde, 0xfa, 0xe6,
	0xbd, 0x7e, 0x7e, 0xbc, 0xbe, 0x99, 0x29, 0xe8, 0xa7, 0x94, 0x11, 0xcb, 0x61, 0xf4, 0xd2, 0xba,
	0xd8, 0x1a, 0x10, 0x81, 0xb7, 0x2c, 0x71, 0x65, 0x86, 0x8c, 0x0a, 0xaa, 0xae, 0xc4, 0x39, 0x33,
	0xce, 0x99, 0x69, 0x0e, 0x7d, 0x02, 0xe8, 0x71, 0x67, 0x8f, 0x84, 0x94, 0xbb, 0x42, 0xd5, 0x60,
	0xf1, 0x94, 0x11, 0x2c, 0x28, 0xd3, 0x94, 0x0d, 0x65, 0x73, 0xe9, 0x28, 0x0b, 0x55, 0x1d, 0xfe,
	0xc3, 0x3e, 0x8d, 0x02, 0xb1, 0x1f, 0x68, 0xb3, 0x32, 0x95, 0xc7, 0x71, 0xce, 0x26, 0x01, 0xf5,
	0xfb, 0x91, 0xd0, 0xe6, 0x92, 0x5c, 0x16, 0xa3, 0x33, 0x50, 0x0b, 0xfc, 0x23, 0xc2, 0x43, 0x1a,
	0x70, 0x32, 0x25, 0xcf, 0x3a, 0x2c, 0x25, 0xcf, 0x05, 0x51, 0xb1, 0x80, 0xde, 0xc2, 0x72, 0x8f,
	0x3b, 0xef, 0x5d, 0x71, 0x66, 0x33, 0x7c, 0x89, 0xbd, 0xe9, 0x48, 0xd0, 0x39, 0xfc, 0x3f, 0x06,
	0xf3, 0x4f, 0x35, 0x9f, 0x4b, 0xcd, 0xbb, 0x31, 0x0e, 0x39, 0x20, 0x81, 0x1d, 0x43, 0x0d, 0x28,
	0x63, 0xf4, 0x92, 0x64, 0x2c, 0x79, 0x1c, 0x0b, 0x90, 0x6d, 0xcd, 0x59, 0xb2, 0x50, 0x7d, 0x02,
	0xcb, 0x36, 0xe1, 0x2e, 0x23, 0xf6, 0x1b, 0x09, 0x9d, 0x12, 0x8d, 0x2f, 0xa2, 0xef, 0x8a, 0xb4,
	0x56, 0xb0, 0xe5, 0xd6, 0xa6, 0x63, 0x6d, 0xb4, 0xa6, 0xae, 0x42, 0xc7, 0xa3, 0x38, 0xd8, 0xb7,
	0xb5, 0x79, 0x99, 0x4a, 0x23, 0xf4, 0x55, 0x5a, 0xde, 0x23, 0x1e, 0x69, 0x61, 0xb9, 0xa9, 0xb3,
	0xab, 0xd0, 0x39, 0x48, 0x08, 0x12, 0xee, 0x34, 0x1a, 0x9b, 0xc6, 0xf9, 0x5b, 0xd3, 0xe8, 0xca,
	0x0e, 0x14, 0xe4, 0xad, 0x3a, 0x30, 0xe6, 0x73, 0xb6, 0xc2, 0x67, 0x95, 0x0c, 0x74, 0x08, 0xdd,
	0x62, 0xf0, 0x77, 0xa9, 0xe7, 0x61, 0x41, 0x18, 0xf6, 0x62, 0x34, 0x3b, 0x59, 0xcc, 0x07, 0xa9,
	0x58, 0x68, 0x9c, 0xcc, 0x8f, 0xb0, 0x5e, 0x85, 0x98, 0x7b, 0x68, 0x46, 0x36, 0x00, 0xe4, 0xa3,
	0x4b, 0x63, 0xad, 0x09, 0x76, 0x69, 0x05, 0xf5, 0x60, 0x6d, 0x6c, 0xee, 0x5b, 0x4b, 0xee, 0xc2,
	0x82, 0xec, 0x6f, 0x8a, 0x99, 0x04, 0xe8, 0x04, 0x1e, 0xd5, 0xc0, 0xb5, 0xd4, 0xdb, 0xd8, 0x75,
	0x74, 0xad, 0x80, 0xde, 0xe3, 0x4e, 0x3f, 0x24, 0xc1, 0x81, 0xfb, 0x39, 0x72, 0x6d, 0x1c, 0xdb,
	0x38, 0x4c, 0xed, 0x4c, 0xb9, 0x57, 0xbb, 0xb0, 0x80, 0x39, 0x27, 0xd9, 0x30, 0x27, 0x41, 0x8c,
	0x15, 0x32, 0xe2, 0xbb, 0x91, 0x9f, 0x8e, 0x53, 0x16, 0x22, 0x06, 0xa8, 0x5e, 0x43, 0x8b, 0x73,
	0x63, 0x1b, 0xba, 0x5e, 0xfa, 0x22, 0x65, 0x87, 0xb7, 0x3f, 0x4e, 0x65, 0x0e, 0x9d, 0xc3, 0x83,
	0x78, 0x0f, 0x7b, 0x94, 0x93, 0xc9, 0x8c, 0x4f, 0x43, 0x76, 0x02, 0x8f, 0x1b, 0xc8, 0x5a, 0x38,
	0x6c, 0xfc, 0x88, 0xdb, 0xbf, 0x3a, 0x30, 0xd7, 0xe3, 0x8e, 0xda, 0x87, 0xc5, 0xec, 0x02, 0x7a,
	0x68, 0xde, 0xb9, 0xa2, 0xcc, 0x62, 0xe8, 0xf5, 0xa7, 0x8d, 0xe9, 0x5c, 0xd0, 0x31, 0x40, 0xe9,
	0x1e, 0xd8, 0xa8, 0x7e, 0xa9, 0xa8, 0xd0, 0x37, 0xef, 0xab, 0xc8, 0x91, 0x7d, 0x58, 0xb9, 0xbb,
	0xa5, 0x9f, 0x35, 0xaa, 0x2a, 0x0a, 0x75, 0xab, 0x65, 0x61, 0x4e, 0x77, 0x01, 0xdd, 0xca, 0x1d,
	0xf9, 0xfc, 0x3e, 0xc1, 0x25, 0xd2, 0xed, 0xf6, 0xb5, 0xe5, 0x06, 0x96, 0x2e, 0xa5, 0x9a, 0x06,
	0x16, 0x15, 0x75, 0x0d, 0xac, 0xb8, 0x6a, 0x8e, 0x01, 0x4a, 0x67, 0xff, 0x46, 0x5d, 0x43, 0xb2,
	0x8a, 0x3a, 0xe4, 0x8a, 0x23, 0xfc, 0x1b, 0xac, 0xd5, 0x1d, 0x07, 0x2f, 0xaa, 0x41, 0x6a, 0xca,
	0xf5, 0x57, 0x13, 0x95, 0xe7, 0x02, 0xae, 0x15, 0xd0, 0x6a, 0x37, 0xa6, 0x59, 0xd3, 0xa1, 0x9a,
	0x7a, 0xfd, 0xf5, 0x64, 0xf5, 0x99, 0x88, 0x9d, 0x9d, 0x9f, 0x43, 0x43, 0xb9, 0x19, 0x1a, 0xca,
	0x9f, 0xa1, 0xa1, 0xfc, 0x18, 0x19, 0x33, 0x37, 0x23, 0x63, 0xe6, 0xf7, 0xc8, 0x98, 0xf9, 0xb0,
	0xe9, 0xb8, 0xe2, 0x2c, 0x1a, 0x98, 0xa7, 0xd4, 0xb7, 0xde, 0x45, 0xd8, 0x66, 0x58, 0x90, 0x3e,
	0x73, 0x2c, 0xf9, 0xbf, 0x78, 0x95, 0xfc, 0x31, 0x8a, 0x2f, 0x21, 0xe1, 0x83, 0x8e, 0xfc, 0x5b,
	0x7c, 0xf9, 0x37, 0x00, 0x00, 0xff, 0xff, 0x71, 0x98, 0x32, 0x55, 0x4b, 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 {
	Deposit(ctx context.Context, in *MsgDeposit, opts ...grpc.CallOption) (*MsgDepositResponse, error)
	Withdrawal(ctx context.Context, in *MsgWithdrawal, opts ...grpc.CallOption) (*MsgWithdrawalResponse, error)
	DepositCollateral(ctx context.Context, in *MsgDepositCollateral, opts ...grpc.CallOption) (*MsgDepositCollateralResponse, error)
	WithdrawalCollateral(ctx context.Context, in *MsgWithdrawalCollateral, opts ...grpc.CallOption) (*MsgWithdrawalCollateralResponse, error)
	CreateLend(ctx context.Context, in *MsgCreateLend, opts ...grpc.CallOption) (*MsgCreateLendResponse, error)
	DeleteLend(ctx context.Context, in *MsgDeleteLend, opts ...grpc.CallOption) (*MsgDeleteLendResponse, 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) Deposit(ctx context.Context, in *MsgDeposit, opts ...grpc.CallOption) (*MsgDepositResponse, error) {
	out := new(MsgDepositResponse)
	err := c.cc.Invoke(ctx, "/core.grow.v1beta1.Msg/Deposit", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

func (c *msgClient) WithdrawalCollateral(ctx context.Context, in *MsgWithdrawalCollateral, opts ...grpc.CallOption) (*MsgWithdrawalCollateralResponse, error) {
	out := new(MsgWithdrawalCollateralResponse)
	err := c.cc.Invoke(ctx, "/core.grow.v1beta1.Msg/WithdrawalCollateral", 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) DeleteLend(ctx context.Context, in *MsgDeleteLend, opts ...grpc.CallOption) (*MsgDeleteLendResponse, error) {
	out := new(MsgDeleteLendResponse)
	err := c.cc.Invoke(ctx, "/core.grow.v1beta1.Msg/DeleteLend", 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 {
	Deposit(context.Context, *MsgDeposit) (*MsgDepositResponse, error)
	Withdrawal(context.Context, *MsgWithdrawal) (*MsgWithdrawalResponse, error)
	DepositCollateral(context.Context, *MsgDepositCollateral) (*MsgDepositCollateralResponse, error)
	WithdrawalCollateral(context.Context, *MsgWithdrawalCollateral) (*MsgWithdrawalCollateralResponse, error)
	CreateLend(context.Context, *MsgCreateLend) (*MsgCreateLendResponse, error)
	DeleteLend(context.Context, *MsgDeleteLend) (*MsgDeleteLendResponse, 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) Deposit(ctx context.Context, req *MsgDeposit) (*MsgDepositResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Deposit not implemented")
}
func (*UnimplementedMsgServer) Withdrawal(ctx context.Context, req *MsgWithdrawal) (*MsgWithdrawalResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Withdrawal not implemented")
}
func (*UnimplementedMsgServer) DepositCollateral(ctx context.Context, req *MsgDepositCollateral) (*MsgDepositCollateralResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DepositCollateral not implemented")
}
func (*UnimplementedMsgServer) WithdrawalCollateral(ctx context.Context, req *MsgWithdrawalCollateral) (*MsgWithdrawalCollateralResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawalCollateral not implemented")
}
func (*UnimplementedMsgServer) CreateLend(ctx context.Context, req *MsgCreateLend) (*MsgCreateLendResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateLend not implemented")
}
func (*UnimplementedMsgServer) DeleteLend(ctx context.Context, req *MsgDeleteLend) (*MsgDeleteLendResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteLend 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_Deposit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgDeposit)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).Deposit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/core.grow.v1beta1.Msg/Deposit",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).Deposit(ctx, req.(*MsgDeposit))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

func _Msg_WithdrawalCollateral_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgWithdrawalCollateral)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).WithdrawalCollateral(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/core.grow.v1beta1.Msg/WithdrawalCollateral",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).WithdrawalCollateral(ctx, req.(*MsgWithdrawalCollateral))
	}
	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_DeleteLend_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgDeleteLend)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).DeleteLend(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/core.grow.v1beta1.Msg/DeleteLend",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).DeleteLend(ctx, req.(*MsgDeleteLend))
	}
	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: "Deposit",
			Handler:    _Msg_Deposit_Handler,
		},
		{
			MethodName: "Withdrawal",
			Handler:    _Msg_Withdrawal_Handler,
		},
		{
			MethodName: "DepositCollateral",
			Handler:    _Msg_DepositCollateral_Handler,
		},
		{
			MethodName: "WithdrawalCollateral",
			Handler:    _Msg_WithdrawalCollateral_Handler,
		},
		{
			MethodName: "CreateLend",
			Handler:    _Msg_CreateLend_Handler,
		},
		{
			MethodName: "DeleteLend",
			Handler:    _Msg_DeleteLend_Handler,
		},
		{
			MethodName: "OpenLiquidationPosition",
			Handler:    _Msg_OpenLiquidationPosition_Handler,
		},
		{
			MethodName: "CloseLiquidationPosition",
			Handler:    _Msg_CloseLiquidationPosition_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "core/grow/v1beta1/tx.proto",
}

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

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

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

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

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

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

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

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

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

func (m *MsgWithdrawalCollateral) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Denom)))
		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 *MsgWithdrawalCollateralResponse) 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 *MsgWithdrawalCollateralResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgWithdrawalCollateralResponse) 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 *MsgDeposit) 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 *MsgDepositResponse) 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 *MsgWithdrawal) 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 *MsgWithdrawalResponse) 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 *MsgCreateLend) 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 *MsgCreateLendResponse) 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 *MsgDeleteLend) 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.LoanId)
	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 *MsgDeleteLendResponse) 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 *MsgDepositCollateral) 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 *MsgDepositCollateralResponse) 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 *MsgWithdrawalCollateral) 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.Denom)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgWithdrawalCollateralResponse) 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 *MsgDeposit) 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: MsgDeposit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeposit: 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 *MsgDepositResponse) 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: MsgDepositResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDepositResponse: 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 *MsgWithdrawal) 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: MsgWithdrawal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawal: 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 *MsgWithdrawalResponse) 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: MsgWithdrawalResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawalResponse: 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 *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 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 *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 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 *MsgDeleteLend) 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: MsgDeleteLend: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeleteLend: 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 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
		case 4:
			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 *MsgDeleteLendResponse) 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: MsgDeleteLendResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeleteLendResponse: 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 *MsgDepositCollateral) 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: MsgDepositCollateral: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDepositCollateral: 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 *MsgDepositCollateralResponse) 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: MsgDepositCollateralResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDepositCollateralResponse: 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 *MsgWithdrawalCollateral) 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: MsgWithdrawalCollateral: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawalCollateral: 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 Denom", 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.Denom = 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 *MsgWithdrawalCollateralResponse) 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: MsgWithdrawalCollateralResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawalCollateralResponse: 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")
)