tx.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: umee/leverage/v1/tx.proto

package types

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

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

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

// MsgSupply represents a user's request to supply assets to the module.
type MsgSupply struct {
	// Supplier is the account address supplying assets and the signer of the message.
	Supplier string     `protobuf:"bytes,1,opt,name=supplier,proto3" json:"supplier,omitempty"`
	Asset    types.Coin `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset"`
}

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

var xxx_messageInfo_MsgSupply proto.InternalMessageInfo

func (*MsgSupply) XXX_MessageName() string {
	return "umee.leverage.v1.MsgSupply"
}

// MsgWithdraw represents a user's request to withdraw supplied assets.
// Asset must be a uToken.
type MsgWithdraw struct {
	// Supplier is the account address withdrawing assets and the signer of the message.
	Supplier string     `protobuf:"bytes,1,opt,name=supplier,proto3" json:"supplier,omitempty"`
	Asset    types.Coin `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset"`
}

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

var xxx_messageInfo_MsgWithdraw proto.InternalMessageInfo

func (*MsgWithdraw) XXX_MessageName() string {
	return "umee.leverage.v1.MsgWithdraw"
}

// MsgMaxWithdraw represents a user's request to withdraw the maximum valid amount of supplied assets.
type MsgMaxWithdraw struct {
	// Supplier is the account address withdrawing assets and the signer of the message.
	Supplier string `protobuf:"bytes,1,opt,name=supplier,proto3" json:"supplier,omitempty"`
	// Denom is base token denom to withdraw
	Denom string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"`
}

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

var xxx_messageInfo_MsgMaxWithdraw proto.InternalMessageInfo

func (*MsgMaxWithdraw) XXX_MessageName() string {
	return "umee.leverage.v1.MsgMaxWithdraw"
}

// MsgCollateralize represents a user's request to enable selected
// uTokens as collateral.
type MsgCollateralize struct {
	// Borrower is the account address adding collateral and the signer of the message.
	Borrower string     `protobuf:"bytes,1,opt,name=borrower,proto3" json:"borrower,omitempty"`
	Asset    types.Coin `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset"`
}

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

var xxx_messageInfo_MsgCollateralize proto.InternalMessageInfo

func (*MsgCollateralize) XXX_MessageName() string {
	return "umee.leverage.v1.MsgCollateralize"
}

// MsgDecollateralize represents a user's request to disable selected
// uTokens as collateral.
type MsgDecollateralize struct {
	// Borrower is the account address removing collateral and the signer of the message.
	Borrower string     `protobuf:"bytes,1,opt,name=borrower,proto3" json:"borrower,omitempty"`
	Asset    types.Coin `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset"`
}

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

var xxx_messageInfo_MsgDecollateralize proto.InternalMessageInfo

func (*MsgDecollateralize) XXX_MessageName() string {
	return "umee.leverage.v1.MsgDecollateralize"
}

// MsgBorrow represents a user's request to borrow a base asset type
// from the module.
type MsgBorrow struct {
	// Borrower is the account address taking a loan and the signer
	// of the message.
	Borrower string     `protobuf:"bytes,1,opt,name=borrower,proto3" json:"borrower,omitempty"`
	Asset    types.Coin `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset"`
}

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

var xxx_messageInfo_MsgBorrow proto.InternalMessageInfo

func (*MsgBorrow) XXX_MessageName() string {
	return "umee.leverage.v1.MsgBorrow"
}

// MsgMaxBorrow represents a user's request to borrow a base asset type
// from the module, using the maximum available amount.
type MsgMaxBorrow struct {
	// Borrower is the account address taking a loan and the signer
	// of the message.
	Borrower string `protobuf:"bytes,1,opt,name=borrower,proto3" json:"borrower,omitempty"`
	Denom    string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"`
}

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

var xxx_messageInfo_MsgMaxBorrow proto.InternalMessageInfo

func (*MsgMaxBorrow) XXX_MessageName() string {
	return "umee.leverage.v1.MsgMaxBorrow"
}

// MsgRepay represents a user's request to repay a borrowed base asset
// type to the module.
type MsgRepay struct {
	// Borrower is the account address repaying a loan and the signer
	// of the message.
	Borrower string     `protobuf:"bytes,1,opt,name=borrower,proto3" json:"borrower,omitempty"`
	Asset    types.Coin `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset"`
}

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

var xxx_messageInfo_MsgRepay proto.InternalMessageInfo

func (*MsgRepay) XXX_MessageName() string {
	return "umee.leverage.v1.MsgRepay"
}

// MsgLiquidate is the request structure for the Liquidate RPC.
type MsgLiquidate struct {
	// Liquidator is the account address performing a liquidation and the signer
	// of the message.
	Liquidator string `protobuf:"bytes,1,opt,name=liquidator,proto3" json:"liquidator,omitempty"`
	// Borrower is the account whose borrow is being repaid, and collateral consumed,
	// by the liquidation. It does not sign the message.
	Borrower string `protobuf:"bytes,2,opt,name=borrower,proto3" json:"borrower,omitempty"`
	// Repayment is the maximum amount of base tokens that the liquidator is willing
	// to repay.
	Repayment types.Coin `protobuf:"bytes,3,opt,name=repayment,proto3" json:"repayment"`
	// RewardDenom is the denom that the liquidator will receive as a liquidation reward.
	// If it is a uToken, the liquidator will receive uTokens from the borrower's
	// collateral. If it is a base token, the uTokens will be redeemed directly at
	// a reduced Liquidation Incentive, and the liquidator will receive base tokens.
	RewardDenom string `protobuf:"bytes,4,opt,name=reward_denom,json=rewardDenom,proto3" json:"reward_denom,omitempty"`
}

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

var xxx_messageInfo_MsgLiquidate proto.InternalMessageInfo

func (*MsgLiquidate) XXX_MessageName() string {
	return "umee.leverage.v1.MsgLiquidate"
}

// MsgLeveragedLiquidate is the request structure for the LeveragedLiquidate RPC.
type MsgLeveragedLiquidate struct {
	// Liquidator is the account address performing a liquidation and the signer
	// of the message.
	Liquidator string `protobuf:"bytes,1,opt,name=liquidator,proto3" json:"liquidator,omitempty"`
	// Borrower is the account whose borrow is being repaid, and collateral consumed,
	// by the liquidation. It does not sign the message.
	Borrower string `protobuf:"bytes,2,opt,name=borrower,proto3" json:"borrower,omitempty"`
	// RepayDenom is the base token that the liquidator will borrow in order to repay on behalf of
	// the borrower.
	RepayDenom string `protobuf:"bytes,3,opt,name=repay_denom,json=repayDenom,proto3" json:"repay_denom,omitempty"`
	// RewardDenom is the uToken denom that the liquidator will receive as a liquidation reward
	// and immediately collateralize.
	RewardDenom string `protobuf:"bytes,4,opt,name=reward_denom,json=rewardDenom,proto3" json:"reward_denom,omitempty"`
}

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

var xxx_messageInfo_MsgLeveragedLiquidate proto.InternalMessageInfo

func (*MsgLeveragedLiquidate) XXX_MessageName() string {
	return "umee.leverage.v1.MsgLeveragedLiquidate"
}

// MsgSupplyCollateral represents a user's request to supply and collateralize assets to the module.
type MsgSupplyCollateral struct {
	// Supplier is the account address supplying assets and the signer of the message.
	Supplier string     `protobuf:"bytes,1,opt,name=supplier,proto3" json:"supplier,omitempty"`
	Asset    types.Coin `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset"`
}

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

var xxx_messageInfo_MsgSupplyCollateral proto.InternalMessageInfo

func (*MsgSupplyCollateral) XXX_MessageName() string {
	return "umee.leverage.v1.MsgSupplyCollateral"
}

// MsgSupplyResponse defines the Msg/Supply response type.
type MsgSupplyResponse struct {
	// Received is the amount of uTokens received.
	Received types.Coin `protobuf:"bytes,1,opt,name=received,proto3" json:"received"`
}

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

var xxx_messageInfo_MsgSupplyResponse proto.InternalMessageInfo

func (*MsgSupplyResponse) XXX_MessageName() string {
	return "umee.leverage.v1.MsgSupplyResponse"
}

// MsgWithdrawResponse defines the Msg/Withdraw response type.
type MsgWithdrawResponse struct {
	// Received is the amount of base tokens received.
	Received types.Coin `protobuf:"bytes,1,opt,name=received,proto3" json:"received"`
}

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

var xxx_messageInfo_MsgWithdrawResponse proto.InternalMessageInfo

func (*MsgWithdrawResponse) XXX_MessageName() string {
	return "umee.leverage.v1.MsgWithdrawResponse"
}

// MsgMaxWithdrawResponse defines the Msg/MaxWithdraw response type.
type MsgMaxWithdrawResponse struct {
	// Withdrawn is the amount of uTokens withdrawn.
	Withdrawn types.Coin `protobuf:"bytes,1,opt,name=withdrawn,proto3" json:"withdrawn"`
	// Received is the amount of base tokens received.
	Received types.Coin `protobuf:"bytes,2,opt,name=received,proto3" json:"received"`
}

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

var xxx_messageInfo_MsgMaxWithdrawResponse proto.InternalMessageInfo

func (*MsgMaxWithdrawResponse) XXX_MessageName() string {
	return "umee.leverage.v1.MsgMaxWithdrawResponse"
}

// MsgCollateralizeResponse defines the Msg/Collateralize response type.
type MsgCollateralizeResponse struct {
}

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

var xxx_messageInfo_MsgCollateralizeResponse proto.InternalMessageInfo

func (*MsgCollateralizeResponse) XXX_MessageName() string {
	return "umee.leverage.v1.MsgCollateralizeResponse"
}

// MsgDecollateralizeResponse defines the Msg/Decollateralize response type.
type MsgDecollateralizeResponse struct {
}

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

var xxx_messageInfo_MsgDecollateralizeResponse proto.InternalMessageInfo

func (*MsgDecollateralizeResponse) XXX_MessageName() string {
	return "umee.leverage.v1.MsgDecollateralizeResponse"
}

// MsgBorrowResponse defines the Msg/Borrow response type.
type MsgBorrowResponse struct {
}

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

var xxx_messageInfo_MsgBorrowResponse proto.InternalMessageInfo

func (*MsgBorrowResponse) XXX_MessageName() string {
	return "umee.leverage.v1.MsgBorrowResponse"
}

// MsgMaxBorrowResponse defines the Msg/MaxBorrow response type.
type MsgMaxBorrowResponse struct {
	// Borrowed is the amount of tokens borrowed.
	Borrowed types.Coin `protobuf:"bytes,1,opt,name=borrowed,proto3" json:"borrowed"`
}

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

var xxx_messageInfo_MsgMaxBorrowResponse proto.InternalMessageInfo

func (*MsgMaxBorrowResponse) XXX_MessageName() string {
	return "umee.leverage.v1.MsgMaxBorrowResponse"
}

// MsgRepayResponse defines the Msg/Repay response type.
type MsgRepayResponse struct {
	// Repaid is the amount of base tokens repaid to the module.
	Repaid types.Coin `protobuf:"bytes,1,opt,name=repaid,proto3" json:"repaid"`
}

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

var xxx_messageInfo_MsgRepayResponse proto.InternalMessageInfo

func (*MsgRepayResponse) XXX_MessageName() string {
	return "umee.leverage.v1.MsgRepayResponse"
}

// MsgLiquidateResponse defines the Msg/Liquidate response type.
type MsgLiquidateResponse struct {
	// Repaid is the amount of borrowed base tokens that the liquidator repaid
	// to the module on behalf of the borrower.
	Repaid types.Coin `protobuf:"bytes,1,opt,name=repaid,proto3" json:"repaid"`
	// Collateral is the amount of the borrower's uToken collateral that
	// was liquidated.
	Collateral types.Coin `protobuf:"bytes,2,opt,name=collateral,proto3" json:"collateral"`
	// Reward is the amount of base tokens that the liquidator received from
	// the module as reward for the liquidation.
	Reward types.Coin `protobuf:"bytes,3,opt,name=reward,proto3" json:"reward"`
}

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

var xxx_messageInfo_MsgLiquidateResponse proto.InternalMessageInfo

func (*MsgLiquidateResponse) XXX_MessageName() string {
	return "umee.leverage.v1.MsgLiquidateResponse"
}

// MsgLeveragedLiquidateResponse defines the Msg/LeveragedLiquidate response type.
type MsgLeveragedLiquidateResponse struct {
	// Repaid is the amount of base tokens that the liquidator borrowed and repaid
	// to the module on behalf of the borrower.
	Repaid types.Coin `protobuf:"bytes,1,opt,name=repaid,proto3" json:"repaid"`
	// Reward is the amount of collateral that the liquidator gained
	// as reward for the liquidation.
	Reward types.Coin `protobuf:"bytes,2,opt,name=reward,proto3" json:"reward"`
}

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

var xxx_messageInfo_MsgLeveragedLiquidateResponse proto.InternalMessageInfo

func (*MsgLeveragedLiquidateResponse) XXX_MessageName() string {
	return "umee.leverage.v1.MsgLeveragedLiquidateResponse"
}

// MsgSupplyCollateralResponse defines the Msg/SupplyCollateral response type.
type MsgSupplyCollateralResponse struct {
	// Collateralized is the amount of uTokens collateralized.
	Collateralized types.Coin `protobuf:"bytes,1,opt,name=collateralized,proto3" json:"collateralized"`
}

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

var xxx_messageInfo_MsgSupplyCollateralResponse proto.InternalMessageInfo

func (*MsgSupplyCollateralResponse) XXX_MessageName() string {
	return "umee.leverage.v1.MsgSupplyCollateralResponse"
}

// MsgGovUpdateRegistry defines the Msg/GovUpdateRegistry request type.
type MsgGovUpdateRegistry struct {
	// authority is the address of the governance account.
	Authority   string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
	Title       string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// add_tokens defines new token settings.
	AddTokens []Token `protobuf:"bytes,4,rep,name=add_tokens,json=addTokens,proto3" json:"add_tokens"`
	// update_tokens defines the new settings for existed tokens.
	UpdateTokens []Token `protobuf:"bytes,5,rep,name=update_tokens,json=updateTokens,proto3" json:"update_tokens"`
}

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

var xxx_messageInfo_MsgGovUpdateRegistry proto.InternalMessageInfo

func (*MsgGovUpdateRegistry) XXX_MessageName() string {
	return "umee.leverage.v1.MsgGovUpdateRegistry"
}

// MsgGovUpdateRegistryResponse defines the Msg/GovUpdateRegistry response type.
type MsgGovUpdateRegistryResponse struct {
}

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

var xxx_messageInfo_MsgGovUpdateRegistryResponse proto.InternalMessageInfo

func (*MsgGovUpdateRegistryResponse) XXX_MessageName() string {
	return "umee.leverage.v1.MsgGovUpdateRegistryResponse"
}
func init() {
	proto.RegisterType((*MsgSupply)(nil), "umee.leverage.v1.MsgSupply")
	proto.RegisterType((*MsgWithdraw)(nil), "umee.leverage.v1.MsgWithdraw")
	proto.RegisterType((*MsgMaxWithdraw)(nil), "umee.leverage.v1.MsgMaxWithdraw")
	proto.RegisterType((*MsgCollateralize)(nil), "umee.leverage.v1.MsgCollateralize")
	proto.RegisterType((*MsgDecollateralize)(nil), "umee.leverage.v1.MsgDecollateralize")
	proto.RegisterType((*MsgBorrow)(nil), "umee.leverage.v1.MsgBorrow")
	proto.RegisterType((*MsgMaxBorrow)(nil), "umee.leverage.v1.MsgMaxBorrow")
	proto.RegisterType((*MsgRepay)(nil), "umee.leverage.v1.MsgRepay")
	proto.RegisterType((*MsgLiquidate)(nil), "umee.leverage.v1.MsgLiquidate")
	proto.RegisterType((*MsgLeveragedLiquidate)(nil), "umee.leverage.v1.MsgLeveragedLiquidate")
	proto.RegisterType((*MsgSupplyCollateral)(nil), "umee.leverage.v1.MsgSupplyCollateral")
	proto.RegisterType((*MsgSupplyResponse)(nil), "umee.leverage.v1.MsgSupplyResponse")
	proto.RegisterType((*MsgWithdrawResponse)(nil), "umee.leverage.v1.MsgWithdrawResponse")
	proto.RegisterType((*MsgMaxWithdrawResponse)(nil), "umee.leverage.v1.MsgMaxWithdrawResponse")
	proto.RegisterType((*MsgCollateralizeResponse)(nil), "umee.leverage.v1.MsgCollateralizeResponse")
	proto.RegisterType((*MsgDecollateralizeResponse)(nil), "umee.leverage.v1.MsgDecollateralizeResponse")
	proto.RegisterType((*MsgBorrowResponse)(nil), "umee.leverage.v1.MsgBorrowResponse")
	proto.RegisterType((*MsgMaxBorrowResponse)(nil), "umee.leverage.v1.MsgMaxBorrowResponse")
	proto.RegisterType((*MsgRepayResponse)(nil), "umee.leverage.v1.MsgRepayResponse")
	proto.RegisterType((*MsgLiquidateResponse)(nil), "umee.leverage.v1.MsgLiquidateResponse")
	proto.RegisterType((*MsgLeveragedLiquidateResponse)(nil), "umee.leverage.v1.MsgLeveragedLiquidateResponse")
	proto.RegisterType((*MsgSupplyCollateralResponse)(nil), "umee.leverage.v1.MsgSupplyCollateralResponse")
	proto.RegisterType((*MsgGovUpdateRegistry)(nil), "umee.leverage.v1.MsgGovUpdateRegistry")
	proto.RegisterType((*MsgGovUpdateRegistryResponse)(nil), "umee.leverage.v1.MsgGovUpdateRegistryResponse")
}

func init() { proto.RegisterFile("umee/leverage/v1/tx.proto", fileDescriptor_72683128ee6e8843) }

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

func (this *MsgGovUpdateRegistry) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MsgGovUpdateRegistry)
	if !ok {
		that2, ok := that.(MsgGovUpdateRegistry)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Authority != that1.Authority {
		return false
	}
	if this.Title != that1.Title {
		return false
	}
	if this.Description != that1.Description {
		return false
	}
	if len(this.AddTokens) != len(that1.AddTokens) {
		return false
	}
	for i := range this.AddTokens {
		if !this.AddTokens[i].Equal(&that1.AddTokens[i]) {
			return false
		}
	}
	if len(this.UpdateTokens) != len(that1.UpdateTokens) {
		return false
	}
	for i := range this.UpdateTokens {
		if !this.UpdateTokens[i].Equal(&that1.UpdateTokens[i]) {
			return false
		}
	}
	return true
}

// 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 {
	// Supply moves tokens from user balance to the module for lending or collateral.
	// The user receives uTokens in return.
	Supply(ctx context.Context, in *MsgSupply, opts ...grpc.CallOption) (*MsgSupplyResponse, error)
	// Withdraw moves previously supplied tokens from the module back to the user balance in
	// exchange for burning uTokens.
	Withdraw(ctx context.Context, in *MsgWithdraw, opts ...grpc.CallOption) (*MsgWithdrawResponse, error)
	// MaxWithdraw moves previously supplied tokens from the module back to the user balance in
	// exchange for burning uTokens. It automatically calculates the maximum valid amount to withdraw.
	// Zero is returned if no more tokens can be withdrawn.
	MaxWithdraw(ctx context.Context, in *MsgMaxWithdraw, opts ...grpc.CallOption) (*MsgMaxWithdrawResponse, error)
	// Collateralize enables selected uTokens as collateral, which moves them to the module.
	Collateralize(ctx context.Context, in *MsgCollateralize, opts ...grpc.CallOption) (*MsgCollateralizeResponse, error)
	// Decollateralize disables selected uTokens as collateral. They are returned to the user's
	// balance from the module.
	Decollateralize(ctx context.Context, in *MsgDecollateralize, opts ...grpc.CallOption) (*MsgDecollateralizeResponse, error)
	// Borrow allows a user to borrow tokens from the module if they have sufficient collateral.
	Borrow(ctx context.Context, in *MsgBorrow, opts ...grpc.CallOption) (*MsgBorrowResponse, error)
	// MaxBorrow allows a user to borrow the maximum amount of tokens their collateral will allow.
	// Zero is returned if no more can be borrowed.
	MaxBorrow(ctx context.Context, in *MsgMaxBorrow, opts ...grpc.CallOption) (*MsgMaxBorrowResponse, error)
	// Repay allows a user to repay previously borrowed tokens and interest.
	Repay(ctx context.Context, in *MsgRepay, opts ...grpc.CallOption) (*MsgRepayResponse, error)
	// Liquidate allows a user to repay a different user's borrowed coins in exchange for some
	// of the target's collateral.
	Liquidate(ctx context.Context, in *MsgLiquidate, opts ...grpc.CallOption) (*MsgLiquidateResponse, error)
	// LeveragedLiquidate allows a user to repay a different user's borrowed coins in exchange for some
	// of the target's collateral. For leveraged liquidations, the tokens to repay are borrowed instead of
	// being taken from the liquidator's wallet, and the reward is immediately collateralized. Borrow
	// limit checks for the liquidator are deferred until after the reward is collateralized, allowing
	// this initial borrow to exceed the liquidator's borrow limit as long as it is healthy by the end
	// of the transaction. Repay amount is calculated automatically, so the liquidator only specifies
	// repay and reward token denoms. For safety, the liquidator cannot exceed 80% of their borrow limit when
	// executing this transaction, instead of the regular 100%. Also allows repayment and reward denoms to
	// be left blank - if not specified, the module will automatically select the first (alphabetically by denom)
	// borrow and/or collateral on the target account and the proceed normally.
	LeveragedLiquidate(ctx context.Context, in *MsgLeveragedLiquidate, opts ...grpc.CallOption) (*MsgLeveragedLiquidateResponse, error)
	// SupplyCollateral combines the Supply and Collateralize actions.
	SupplyCollateral(ctx context.Context, in *MsgSupplyCollateral, opts ...grpc.CallOption) (*MsgSupplyCollateralResponse, error)
	// GovUpdateRegistry adds new tokens to the token registry or
	// updates existing tokens with new settings.
	GovUpdateRegistry(ctx context.Context, in *MsgGovUpdateRegistry, opts ...grpc.CallOption) (*MsgGovUpdateRegistryResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

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

func (c *msgClient) Supply(ctx context.Context, in *MsgSupply, opts ...grpc.CallOption) (*MsgSupplyResponse, error) {
	out := new(MsgSupplyResponse)
	err := c.cc.Invoke(ctx, "/umee.leverage.v1.Msg/Supply", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Withdraw(ctx context.Context, in *MsgWithdraw, opts ...grpc.CallOption) (*MsgWithdrawResponse, error) {
	out := new(MsgWithdrawResponse)
	err := c.cc.Invoke(ctx, "/umee.leverage.v1.Msg/Withdraw", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) MaxWithdraw(ctx context.Context, in *MsgMaxWithdraw, opts ...grpc.CallOption) (*MsgMaxWithdrawResponse, error) {
	out := new(MsgMaxWithdrawResponse)
	err := c.cc.Invoke(ctx, "/umee.leverage.v1.Msg/MaxWithdraw", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Collateralize(ctx context.Context, in *MsgCollateralize, opts ...grpc.CallOption) (*MsgCollateralizeResponse, error) {
	out := new(MsgCollateralizeResponse)
	err := c.cc.Invoke(ctx, "/umee.leverage.v1.Msg/Collateralize", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Decollateralize(ctx context.Context, in *MsgDecollateralize, opts ...grpc.CallOption) (*MsgDecollateralizeResponse, error) {
	out := new(MsgDecollateralizeResponse)
	err := c.cc.Invoke(ctx, "/umee.leverage.v1.Msg/Decollateralize", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Borrow(ctx context.Context, in *MsgBorrow, opts ...grpc.CallOption) (*MsgBorrowResponse, error) {
	out := new(MsgBorrowResponse)
	err := c.cc.Invoke(ctx, "/umee.leverage.v1.Msg/Borrow", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) MaxBorrow(ctx context.Context, in *MsgMaxBorrow, opts ...grpc.CallOption) (*MsgMaxBorrowResponse, error) {
	out := new(MsgMaxBorrowResponse)
	err := c.cc.Invoke(ctx, "/umee.leverage.v1.Msg/MaxBorrow", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Repay(ctx context.Context, in *MsgRepay, opts ...grpc.CallOption) (*MsgRepayResponse, error) {
	out := new(MsgRepayResponse)
	err := c.cc.Invoke(ctx, "/umee.leverage.v1.Msg/Repay", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Liquidate(ctx context.Context, in *MsgLiquidate, opts ...grpc.CallOption) (*MsgLiquidateResponse, error) {
	out := new(MsgLiquidateResponse)
	err := c.cc.Invoke(ctx, "/umee.leverage.v1.Msg/Liquidate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) LeveragedLiquidate(ctx context.Context, in *MsgLeveragedLiquidate, opts ...grpc.CallOption) (*MsgLeveragedLiquidateResponse, error) {
	out := new(MsgLeveragedLiquidateResponse)
	err := c.cc.Invoke(ctx, "/umee.leverage.v1.Msg/LeveragedLiquidate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) SupplyCollateral(ctx context.Context, in *MsgSupplyCollateral, opts ...grpc.CallOption) (*MsgSupplyCollateralResponse, error) {
	out := new(MsgSupplyCollateralResponse)
	err := c.cc.Invoke(ctx, "/umee.leverage.v1.Msg/SupplyCollateral", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) GovUpdateRegistry(ctx context.Context, in *MsgGovUpdateRegistry, opts ...grpc.CallOption) (*MsgGovUpdateRegistryResponse, error) {
	out := new(MsgGovUpdateRegistryResponse)
	err := c.cc.Invoke(ctx, "/umee.leverage.v1.Msg/GovUpdateRegistry", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// Supply moves tokens from user balance to the module for lending or collateral.
	// The user receives uTokens in return.
	Supply(context.Context, *MsgSupply) (*MsgSupplyResponse, error)
	// Withdraw moves previously supplied tokens from the module back to the user balance in
	// exchange for burning uTokens.
	Withdraw(context.Context, *MsgWithdraw) (*MsgWithdrawResponse, error)
	// MaxWithdraw moves previously supplied tokens from the module back to the user balance in
	// exchange for burning uTokens. It automatically calculates the maximum valid amount to withdraw.
	// Zero is returned if no more tokens can be withdrawn.
	MaxWithdraw(context.Context, *MsgMaxWithdraw) (*MsgMaxWithdrawResponse, error)
	// Collateralize enables selected uTokens as collateral, which moves them to the module.
	Collateralize(context.Context, *MsgCollateralize) (*MsgCollateralizeResponse, error)
	// Decollateralize disables selected uTokens as collateral. They are returned to the user's
	// balance from the module.
	Decollateralize(context.Context, *MsgDecollateralize) (*MsgDecollateralizeResponse, error)
	// Borrow allows a user to borrow tokens from the module if they have sufficient collateral.
	Borrow(context.Context, *MsgBorrow) (*MsgBorrowResponse, error)
	// MaxBorrow allows a user to borrow the maximum amount of tokens their collateral will allow.
	// Zero is returned if no more can be borrowed.
	MaxBorrow(context.Context, *MsgMaxBorrow) (*MsgMaxBorrowResponse, error)
	// Repay allows a user to repay previously borrowed tokens and interest.
	Repay(context.Context, *MsgRepay) (*MsgRepayResponse, error)
	// Liquidate allows a user to repay a different user's borrowed coins in exchange for some
	// of the target's collateral.
	Liquidate(context.Context, *MsgLiquidate) (*MsgLiquidateResponse, error)
	// LeveragedLiquidate allows a user to repay a different user's borrowed coins in exchange for some
	// of the target's collateral. For leveraged liquidations, the tokens to repay are borrowed instead of
	// being taken from the liquidator's wallet, and the reward is immediately collateralized. Borrow
	// limit checks for the liquidator are deferred until after the reward is collateralized, allowing
	// this initial borrow to exceed the liquidator's borrow limit as long as it is healthy by the end
	// of the transaction. Repay amount is calculated automatically, so the liquidator only specifies
	// repay and reward token denoms. For safety, the liquidator cannot exceed 80% of their borrow limit when
	// executing this transaction, instead of the regular 100%. Also allows repayment and reward denoms to
	// be left blank - if not specified, the module will automatically select the first (alphabetically by denom)
	// borrow and/or collateral on the target account and the proceed normally.
	LeveragedLiquidate(context.Context, *MsgLeveragedLiquidate) (*MsgLeveragedLiquidateResponse, error)
	// SupplyCollateral combines the Supply and Collateralize actions.
	SupplyCollateral(context.Context, *MsgSupplyCollateral) (*MsgSupplyCollateralResponse, error)
	// GovUpdateRegistry adds new tokens to the token registry or
	// updates existing tokens with new settings.
	GovUpdateRegistry(context.Context, *MsgGovUpdateRegistry) (*MsgGovUpdateRegistryResponse, error)
}

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

func (*UnimplementedMsgServer) Supply(ctx context.Context, req *MsgSupply) (*MsgSupplyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Supply not implemented")
}
func (*UnimplementedMsgServer) Withdraw(ctx context.Context, req *MsgWithdraw) (*MsgWithdrawResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Withdraw not implemented")
}
func (*UnimplementedMsgServer) MaxWithdraw(ctx context.Context, req *MsgMaxWithdraw) (*MsgMaxWithdrawResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MaxWithdraw not implemented")
}
func (*UnimplementedMsgServer) Collateralize(ctx context.Context, req *MsgCollateralize) (*MsgCollateralizeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Collateralize not implemented")
}
func (*UnimplementedMsgServer) Decollateralize(ctx context.Context, req *MsgDecollateralize) (*MsgDecollateralizeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Decollateralize not implemented")
}
func (*UnimplementedMsgServer) Borrow(ctx context.Context, req *MsgBorrow) (*MsgBorrowResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Borrow not implemented")
}
func (*UnimplementedMsgServer) MaxBorrow(ctx context.Context, req *MsgMaxBorrow) (*MsgMaxBorrowResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MaxBorrow not implemented")
}
func (*UnimplementedMsgServer) Repay(ctx context.Context, req *MsgRepay) (*MsgRepayResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Repay not implemented")
}
func (*UnimplementedMsgServer) Liquidate(ctx context.Context, req *MsgLiquidate) (*MsgLiquidateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Liquidate not implemented")
}
func (*UnimplementedMsgServer) LeveragedLiquidate(ctx context.Context, req *MsgLeveragedLiquidate) (*MsgLeveragedLiquidateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LeveragedLiquidate not implemented")
}
func (*UnimplementedMsgServer) SupplyCollateral(ctx context.Context, req *MsgSupplyCollateral) (*MsgSupplyCollateralResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SupplyCollateral not implemented")
}
func (*UnimplementedMsgServer) GovUpdateRegistry(ctx context.Context, req *MsgGovUpdateRegistry) (*MsgGovUpdateRegistryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GovUpdateRegistry not implemented")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "umee.leverage.v1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Supply",
			Handler:    _Msg_Supply_Handler,
		},
		{
			MethodName: "Withdraw",
			Handler:    _Msg_Withdraw_Handler,
		},
		{
			MethodName: "MaxWithdraw",
			Handler:    _Msg_MaxWithdraw_Handler,
		},
		{
			MethodName: "Collateralize",
			Handler:    _Msg_Collateralize_Handler,
		},
		{
			MethodName: "Decollateralize",
			Handler:    _Msg_Decollateralize_Handler,
		},
		{
			MethodName: "Borrow",
			Handler:    _Msg_Borrow_Handler,
		},
		{
			MethodName: "MaxBorrow",
			Handler:    _Msg_MaxBorrow_Handler,
		},
		{
			MethodName: "Repay",
			Handler:    _Msg_Repay_Handler,
		},
		{
			MethodName: "Liquidate",
			Handler:    _Msg_Liquidate_Handler,
		},
		{
			MethodName: "LeveragedLiquidate",
			Handler:    _Msg_LeveragedLiquidate_Handler,
		},
		{
			MethodName: "SupplyCollateral",
			Handler:    _Msg_SupplyCollateral_Handler,
		},
		{
			MethodName: "GovUpdateRegistry",
			Handler:    _Msg_GovUpdateRegistry_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "umee/leverage/v1/tx.proto",
}

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

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

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

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

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

func (m *MsgMaxWithdraw) 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.Supplier) > 0 {
		i -= len(m.Supplier)
		copy(dAtA[i:], m.Supplier)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Supplier)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgCollateralize) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Asset.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	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 *MsgDecollateralize) 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 *MsgDecollateralize) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgDecollateralize) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Asset.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	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 *MsgBorrow) 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 *MsgBorrow) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgBorrow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Asset.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	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 *MsgMaxBorrow) 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 *MsgMaxBorrow) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *MsgRepay) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Asset.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	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 *MsgLiquidate) 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 *MsgLiquidate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgLiquidate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RewardDenom) > 0 {
		i -= len(m.RewardDenom)
		copy(dAtA[i:], m.RewardDenom)
		i = encodeVarintTx(dAtA, i, uint64(len(m.RewardDenom)))
		i--
		dAtA[i] = 0x22
	}
	{
		size, err := m.Repayment.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	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] = 0x12
	}
	if len(m.Liquidator) > 0 {
		i -= len(m.Liquidator)
		copy(dAtA[i:], m.Liquidator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Liquidator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgLeveragedLiquidate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RewardDenom) > 0 {
		i -= len(m.RewardDenom)
		copy(dAtA[i:], m.RewardDenom)
		i = encodeVarintTx(dAtA, i, uint64(len(m.RewardDenom)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepayDenom) > 0 {
		i -= len(m.RepayDenom)
		copy(dAtA[i:], m.RepayDenom)
		i = encodeVarintTx(dAtA, i, uint64(len(m.RepayDenom)))
		i--
		dAtA[i] = 0x1a
	}
	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] = 0x12
	}
	if len(m.Liquidator) > 0 {
		i -= len(m.Liquidator)
		copy(dAtA[i:], m.Liquidator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Liquidator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *MsgLiquidateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Reward.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Collateral.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Repaid.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *MsgGovUpdateRegistry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.UpdateTokens) > 0 {
		for iNdEx := len(m.UpdateTokens) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.UpdateTokens[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.AddTokens) > 0 {
		for iNdEx := len(m.AddTokens) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AddTokens[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Title) > 0 {
		i -= len(m.Title)
		copy(dAtA[i:], m.Title)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Authority) > 0 {
		i -= len(m.Authority)
		copy(dAtA[i:], m.Authority)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Authority)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
	offset -= sovTx(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MsgSupply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Supplier)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Asset.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

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

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

func (m *MsgDecollateralize) 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 = m.Asset.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *MsgBorrow) 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 = m.Asset.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *MsgMaxBorrow) 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.Denom)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgRepay) 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 = m.Asset.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *MsgLiquidate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Liquidator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Borrower)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Repayment.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.RewardDenom)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgLeveragedLiquidate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Liquidator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Borrower)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.RepayDenom)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.RewardDenom)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

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

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

func (m *MsgMaxWithdrawResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Withdrawn.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.Received.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

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

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

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

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

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

func (m *MsgLiquidateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Repaid.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.Collateral.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.Reward.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *MsgLeveragedLiquidateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Repaid.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.Reward.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

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

func (m *MsgGovUpdateRegistry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Authority)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.AddTokens) > 0 {
		for _, e := range m.AddTokens {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if len(m.UpdateTokens) > 0 {
		for _, e := range m.UpdateTokens {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	return n
}

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgDecollateralize) 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: MsgDecollateralize: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDecollateralize: 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 Asset", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Asset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgBorrow) 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: MsgBorrow: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgBorrow: 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 Asset", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Asset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgMaxBorrow) 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: MsgMaxBorrow: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgMaxBorrow: 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 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 *MsgRepay) 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: MsgRepay: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRepay: 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 Asset", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Asset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgLiquidate) 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: MsgLiquidate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgLiquidate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Liquidator", 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.Liquidator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Repayment", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Repayment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RewardDenom", 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.RewardDenom = 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 *MsgLeveragedLiquidate) 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: MsgLeveragedLiquidate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgLeveragedLiquidate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Liquidator", 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.Liquidator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepayDenom", 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.RepayDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RewardDenom", 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.RewardDenom = 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 *MsgSupplyCollateral) 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: MsgSupplyCollateral: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSupplyCollateral: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Supplier", 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.Supplier = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Asset", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Asset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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