leverage.pb.go

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

package types

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

// Params defines the parameters for the leverage module.
type Params struct {
	// The complete_liquidation_threshold determines how far over their borrow limit a borrower
	// must be in order for their positions to be liquidated fully in a single event.
	CompleteLiquidationThreshold github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=complete_liquidation_threshold,json=completeLiquidationThreshold,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"complete_liquidation_threshold" yaml:"complete_liquidation_threshold"`
	// The minimum_close_factor determines the portion of a borrower's position that can be
	// liquidated in a single event, when the borrower is just barely over their borrow limit.
	MinimumCloseFactor github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=minimum_close_factor,json=minimumCloseFactor,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"minimum_close_factor" yaml:"minimum_close_factor"`
	// The oracle_reward_factor determines the portion of interest accrued on borrows that is
	// sent to the oracle module to fund its reward pool.
	OracleRewardFactor github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=oracle_reward_factor,json=oracleRewardFactor,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"oracle_reward_factor" yaml:"oracle_reward_factor"`
}

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

var xxx_messageInfo_Params proto.InternalMessageInfo

// Token defines a token, along with its capital metadata, in the Umee capital
// facility that can be loaned and borrowed.
type Token struct {
	// The base_denom defines the denomination of the underlying base token.
	BaseDenom string `protobuf:"bytes,1,opt,name=base_denom,json=baseDenom,proto3" json:"base_denom,omitempty" yaml:"base_denom"`
	// The reserve factor defines what portion of accrued interest of the asset type
	// goes to reserves.
	ReserveFactor github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=reserve_factor,json=reserveFactor,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"reserve_factor" yaml:"reserve_factor"`
	// The collateral_weight defines what amount of the total value of the asset
	// can contribute to a users borrowing power. If the collateral_weight is zero,
	// using this asset as collateral against borrowing will be disabled.
	CollateralWeight github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=collateral_weight,json=collateralWeight,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"collateral_weight" yaml:"collateral_weight"`
	// The base_borrow_rate defines the base interest rate for borrowing this
	// asset.
	BaseBorrowRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=base_borrow_rate,json=baseBorrowRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"base_borrow_rate" yaml:"base_borrow_rate"`
	// The kink_borrow_rate defines the interest rate for borrowing this
	// asset when utilization is at the 'kink' utilization value as defined
	// on the utilization:interest graph.
	KinkBorrowRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,5,opt,name=kink_borrow_rate,json=kinkBorrowRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"kink_borrow_rate" yaml:"kink_borrow_rate"`
	// The max_borrow_rate defines the interest rate for borrowing this
	// asset (seen when utilization is 100%).
	MaxBorrowRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=max_borrow_rate,json=maxBorrowRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_borrow_rate" yaml:"max_borrow_rate"`
	// The kink_utilization_rate defines the borrow utilization rate for this
	// asset where the 'kink' on the utilization:interest graph occurs.
	KinkUtilizationRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,7,opt,name=kink_utilization_rate,json=kinkUtilizationRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"kink_utilization_rate" yaml:"kink_utilization_rate"`
	// The liquidation_incentive determines the portion of bonus collateral of
	// a token type liquidators receive as a liquidation reward.
	LiquidationIncentive github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,8,opt,name=liquidation_incentive,json=liquidationIncentive,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"liquidation_incentive" yaml:"liquidation_incentive"`
	// The symbol_denom and exponent are solely used to update the oracle's accept
	// list of allowed tokens.
	SymbolDenom string `protobuf:"bytes,9,opt,name=symbol_denom,json=symbolDenom,proto3" json:"symbol_denom,omitempty" yaml:"symbol_denom"`
	Exponent    uint32 `protobuf:"varint,10,opt,name=exponent,proto3" json:"exponent,omitempty" yaml:"exponent"`
}

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

var xxx_messageInfo_Token proto.InternalMessageInfo

func (m *Token) GetBaseDenom() string {
	if m != nil {
		return m.BaseDenom
	}
	return ""
}

func (m *Token) GetSymbolDenom() string {
	if m != nil {
		return m.SymbolDenom
	}
	return ""
}

func (m *Token) GetExponent() uint32 {
	if m != nil {
		return m.Exponent
	}
	return 0
}

func init() {
	proto.RegisterType((*Params)(nil), "umeenetwork.umee.leverage.v1beta1.Params")
	proto.RegisterType((*Token)(nil), "umeenetwork.umee.leverage.v1beta1.Token")
}

func init() {
	proto.RegisterFile("umee/leverage/v1beta1/leverage.proto", fileDescriptor_f9aab5daf3352690)
}

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

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

	that1, ok := that.(*Token)
	if !ok {
		that2, ok := that.(Token)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.BaseDenom != that1.BaseDenom {
		return false
	}
	if !this.ReserveFactor.Equal(that1.ReserveFactor) {
		return false
	}
	if !this.CollateralWeight.Equal(that1.CollateralWeight) {
		return false
	}
	if !this.BaseBorrowRate.Equal(that1.BaseBorrowRate) {
		return false
	}
	if !this.KinkBorrowRate.Equal(that1.KinkBorrowRate) {
		return false
	}
	if !this.MaxBorrowRate.Equal(that1.MaxBorrowRate) {
		return false
	}
	if !this.KinkUtilizationRate.Equal(that1.KinkUtilizationRate) {
		return false
	}
	if !this.LiquidationIncentive.Equal(that1.LiquidationIncentive) {
		return false
	}
	if this.SymbolDenom != that1.SymbolDenom {
		return false
	}
	if this.Exponent != that1.Exponent {
		return false
	}
	return true
}
func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.OracleRewardFactor.Size()
		i -= size
		if _, err := m.OracleRewardFactor.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.MinimumCloseFactor.Size()
		i -= size
		if _, err := m.MinimumCloseFactor.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.CompleteLiquidationThreshold.Size()
		i -= size
		if _, err := m.CompleteLiquidationThreshold.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	return len(dAtA) - i, nil
}

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

func (m *Token) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Exponent != 0 {
		i = encodeVarintLeverage(dAtA, i, uint64(m.Exponent))
		i--
		dAtA[i] = 0x50
	}
	if len(m.SymbolDenom) > 0 {
		i -= len(m.SymbolDenom)
		copy(dAtA[i:], m.SymbolDenom)
		i = encodeVarintLeverage(dAtA, i, uint64(len(m.SymbolDenom)))
		i--
		dAtA[i] = 0x4a
	}
	{
		size := m.LiquidationIncentive.Size()
		i -= size
		if _, err := m.LiquidationIncentive.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	{
		size := m.KinkUtilizationRate.Size()
		i -= size
		if _, err := m.KinkUtilizationRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size := m.MaxBorrowRate.Size()
		i -= size
		if _, err := m.MaxBorrowRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size := m.KinkBorrowRate.Size()
		i -= size
		if _, err := m.KinkBorrowRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.BaseBorrowRate.Size()
		i -= size
		if _, err := m.BaseBorrowRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.CollateralWeight.Size()
		i -= size
		if _, err := m.CollateralWeight.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.ReserveFactor.Size()
		i -= size
		if _, err := m.ReserveFactor.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.BaseDenom) > 0 {
		i -= len(m.BaseDenom)
		copy(dAtA[i:], m.BaseDenom)
		i = encodeVarintLeverage(dAtA, i, uint64(len(m.BaseDenom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintLeverage(dAtA []byte, offset int, v uint64) int {
	offset -= sovLeverage(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Params) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.CompleteLiquidationThreshold.Size()
	n += 1 + l + sovLeverage(uint64(l))
	l = m.MinimumCloseFactor.Size()
	n += 1 + l + sovLeverage(uint64(l))
	l = m.OracleRewardFactor.Size()
	n += 1 + l + sovLeverage(uint64(l))
	return n
}

func (m *Token) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BaseDenom)
	if l > 0 {
		n += 1 + l + sovLeverage(uint64(l))
	}
	l = m.ReserveFactor.Size()
	n += 1 + l + sovLeverage(uint64(l))
	l = m.CollateralWeight.Size()
	n += 1 + l + sovLeverage(uint64(l))
	l = m.BaseBorrowRate.Size()
	n += 1 + l + sovLeverage(uint64(l))
	l = m.KinkBorrowRate.Size()
	n += 1 + l + sovLeverage(uint64(l))
	l = m.MaxBorrowRate.Size()
	n += 1 + l + sovLeverage(uint64(l))
	l = m.KinkUtilizationRate.Size()
	n += 1 + l + sovLeverage(uint64(l))
	l = m.LiquidationIncentive.Size()
	n += 1 + l + sovLeverage(uint64(l))
	l = len(m.SymbolDenom)
	if l > 0 {
		n += 1 + l + sovLeverage(uint64(l))
	}
	if m.Exponent != 0 {
		n += 1 + sovLeverage(uint64(m.Exponent))
	}
	return n
}

func sovLeverage(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozLeverage(x uint64) (n int) {
	return sovLeverage(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Params) 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 ErrIntOverflowLeverage
			}
			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: Params: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompleteLiquidationThreshold", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				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 ErrInvalidLengthLeverage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLeverage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CompleteLiquidationThreshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinimumCloseFactor", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				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 ErrInvalidLengthLeverage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLeverage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinimumCloseFactor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleRewardFactor", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				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 ErrInvalidLengthLeverage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLeverage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OracleRewardFactor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLeverage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLeverage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Token) 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 ErrIntOverflowLeverage
			}
			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: Token: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Token: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseDenom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				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 ErrInvalidLengthLeverage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLeverage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BaseDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReserveFactor", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				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 ErrInvalidLengthLeverage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLeverage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ReserveFactor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollateralWeight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				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 ErrInvalidLengthLeverage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLeverage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CollateralWeight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseBorrowRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				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 ErrInvalidLengthLeverage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLeverage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BaseBorrowRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KinkBorrowRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				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 ErrInvalidLengthLeverage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLeverage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.KinkBorrowRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxBorrowRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				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 ErrInvalidLengthLeverage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLeverage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MaxBorrowRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KinkUtilizationRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				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 ErrInvalidLengthLeverage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLeverage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.KinkUtilizationRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LiquidationIncentive", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				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 ErrInvalidLengthLeverage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLeverage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.LiquidationIncentive.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SymbolDenom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				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 ErrInvalidLengthLeverage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLeverage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SymbolDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exponent", wireType)
			}
			m.Exponent = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Exponent |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLeverage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLeverage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthLeverage        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLeverage          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupLeverage = fmt.Errorf("proto: unexpected end of group")
)