leverage.pb.go

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

package types

import (
	fmt "fmt"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/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 {
	// Complete Liquidation Threshold determines how far between
	// liquidation_threshold (LT) and collateral_value (CV) a borrower's
	// borrowed value must have progressed in order to allow a full liquidation.
	// 0.3 indicates 30% of the way from LT to CV.
	// See also `minimum_close_factor` for more information.
	// Valid values: 0-1.
	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"`
	// Close Factor determines the portion of a borrower's position that can be
	// liquidated in a single event. Minimum Close Factor is Close Factor at
	// liquidation_threshold. 0.1 means that that 10% of the borrower position can
	// be liquidated when the borrowed value passes the liquidation_threshold.
	// close_factor scales linearly between minimum_close_factor and 1.0,
	// reaching its maximum when borrowed value passes
	// complete_liquidation_threshold. We can put it into the picture:
	//
	//	           borrowed          CV := collateral
	//	           value                   value
	//	--- | ------- | ----- | -------- | ------->
	//	   LV                 CL
	//
	// LV = liquidation value = liquidation_threshold * CV
	// CL = LV + (CV-LV) * complete_liquidation_threshold
	//
	//	is the borrowed value above which close factor will be 1.
	//
	// Valid values: 0-1.
	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"`
	// Oracle Reward Factor determines the portion of interest accrued on
	// borrows that is sent to the oracle module to fund its reward pool.
	// Valid values: 0-1.
	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"`
	// Small Liquidation Size determines the USD value at which a borrow is
	// considered small enough to be liquidated in a single transaction, bypassing
	// dynamic close factor.
	SmallLiquidationSize github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,5,opt,name=small_liquidation_size,json=smallLiquidationSize,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"small_liquidation_size" yaml:"small_liquidation_size"`
	// Direct Liquidation Fee is a reduction factor in liquidation incentive
	// experienced by liquidators who choose to receive base assets instead of
	// uTokens as liquidation rewards.
	// Valid values: 0-1.
	DirectLiquidationFee github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=direct_liquidation_fee,json=directLiquidationFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"direct_liquidation_fee" yaml:"direct_liquidation_fee"`
}

func (m *Params) Reset()         { *m = Params{} }
func (m *Params) String() string { return proto.CompactTextString(m) }
func (*Params) ProtoMessage()    {}
func (*Params) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cb1bf9ea641ecc6, []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 metadata and parameters, in the Umee
// capital facility that can be supplied and borrowed.
// See https://github.com/umee-network/umee/blob/main/docs/design_docs/010-market-params.md
// for more details.
type Token struct {
	// Base Denom is the denomination of the underlying base token. Must be the base
	// denom as registered in the Bank module (so IBC denom for IBC tokens).
	BaseDenom string `protobuf:"bytes,1,opt,name=base_denom,json=baseDenom,proto3" json:"base_denom,omitempty" yaml:"base_denom"`
	// Reserve Factor defines what portion of accrued interest goes to reserves
	// when this token is borrowed.
	// Valid values: 0-1.
	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"`
	// Collateral Weight defines what portion 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.
	// Must be smaller than `liquidation_threshold`.
	// Valid values: 0-1.
	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"`
	// Liquidation Threshold defines what amount of the total value of the
	// asset as a collateral can contribute to a user's liquidation threshold
	// (above which they become eligible for liquidation).
	// Must be bigger than `collateral_weight`.
	// Valid values: 0-1.
	// See also: min_close_factor.
	LiquidationThreshold github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=liquidation_threshold,json=liquidationThreshold,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"liquidation_threshold" yaml:"liquidation_threshold"`
	// Base Borrow Rate defines the minimum interest rate for borrowing this
	// asset.
	// Valid values: 0-∞
	BaseBorrowRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,5,opt,name=base_borrow_rate,json=baseBorrowRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"base_borrow_rate" yaml:"base_borrow_rate"`
	// Kink Borrow Rate defines the interest rate for borrowing this
	// asset when supply utilization is equal to 'kink_utilization'.
	// Valid values: 0-∞
	KinkBorrowRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=kink_borrow_rate,json=kinkBorrowRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"kink_borrow_rate" yaml:"kink_borrow_rate"`
	// Max Borrow Rate defines the interest rate for borrowing this
	// asset when supply utilization is at its maximum.
	// Valid values: 0-∞
	MaxBorrowRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,7,opt,name=max_borrow_rate,json=maxBorrowRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_borrow_rate" yaml:"max_borrow_rate"`
	// Kink Utilization defines the supply utilization value where
	// the kink in the borrow interest rate function occurs.
	// Valid values: 0-1.
	KinkUtilization github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,8,opt,name=kink_utilization,json=kinkUtilization,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"kink_utilization" yaml:"kink_utilization"`
	// Liquidation Incentive determines the portion of bonus collateral of
	// a token type liquidators receive as a liquidation reward.
	// Valid values: 0-1.
	LiquidationIncentive github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,9,opt,name=liquidation_incentive,json=liquidationIncentive,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"liquidation_incentive" yaml:"liquidation_incentive"`
	// Symbol Denom is the human readable denomination of this token.
	SymbolDenom string `protobuf:"bytes,10,opt,name=symbol_denom,json=symbolDenom,proto3" json:"symbol_denom,omitempty" yaml:"symbol_denom"`
	// Exponent is the power of ten by which to multiply, in order to convert
	// an amount of the token denoted in its symbol denom to the actual amount
	// of its base denom.
	Exponent uint32 `protobuf:"varint,11,opt,name=exponent,proto3" json:"exponent,omitempty" yaml:"exponent"`
	// Enable Msg Supply allows supplying for lending or collateral using this
	// token. `false` means that a token can no longer be supplied.
	// Note that withdrawing is always enabled. Disabling supply would
	// be one step in phasing out an asset type.
	EnableMsgSupply bool `protobuf:"varint,12,opt,name=enable_msg_supply,json=enableMsgSupply,proto3" json:"enable_msg_supply,omitempty" yaml:"enable_msg_supply"`
	// Enable Msg Borrow allows borrowing of this token. Note that repaying is
	// always enabled. Disabling borrowing would be one step in phasing out an
	// asset type, but could also be used from the start for asset types meant
	// to be collateral only, like meTokens.
	EnableMsgBorrow bool `protobuf:"varint,13,opt,name=enable_msg_borrow,json=enableMsgBorrow,proto3" json:"enable_msg_borrow,omitempty" yaml:"enable_msg_borrow"`
	// Blacklist should only be used to eliminate an asset completely. A blacklisted
	// asset is treated as though its oracle price is zero, and thus ignored by
	// calculations such as collateral value and borrow limit. Can still be repaid
	// or withdrawn, but not liquidated. A blacklisted token must have enable_msg_supply
	// and enable_msg_borrow set to false. Such tokens can be safely removed from the
	// oracle and price feeder as well.
	Blacklist bool `protobuf:"varint,14,opt,name=blacklist,proto3" json:"blacklist,omitempty"`
	// Max Collateral Share specifies how much of the system's overall collateral
	// can be provided by a given token. 1.0 means that the token has no restriction.
	// 0.1 means maximum 10% of system's total collateral value can be provided by this token.
	// Valid values: 0-1.
	MaxCollateralShare github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,15,opt,name=max_collateral_share,json=maxCollateralShare,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_collateral_share" yaml:"max_collateral_share"`
	// Max Supply Utilization specifies the maximum supply utilization a token is
	// allowed to reach as a direct result of user borrowing. New borrows are not allowed when
	// the supply utilization is above `max_supply_utilization`.
	//
	//	supply_utilization(token) = total_borrowed(token) / total_supply(token)
	//
	// Valid values: 0-1.
	MaxSupplyUtilization github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,16,opt,name=max_supply_utilization,json=maxSupplyUtilization,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_supply_utilization" yaml:"max_supply_utilization"`
	// Min Collateral Liquidity specifies min limit for the following function:
	//
	//	collateral_liquidity(token) = available(token) / total_collateral(token)
	//
	// Borrowing, collateralizing, or withdrawing assets is not allowed when the
	// result of such action invalidates min_collateral_liquidity.
	// Liquidity can only drop below this value due to interest or liquidations.
	// The goal is to assure that there is enough available (not borrowed) token to be available
	// for withdraw when there is a collateral liquidation and the liquidator needs to
	// withdraw uToken.
	// Valid values: 0 - inf
	MinCollateralLiquidity github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,17,opt,name=min_collateral_liquidity,json=minCollateralLiquidity,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"min_collateral_liquidity" yaml:"min_collateral_liquidity"`
	// Max Supply is the maximum amount of tokens the protocol can hold.
	// Adding more supply of the given token to the protocol will return an error.
	// Must be a non negative value. 0 means that there is no limit.
	// To mark a token as not valid for supply, `msg_supply` must be set to false.
	MaxSupply github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,18,opt,name=max_supply,json=maxSupply,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"max_supply" yaml:"max_supply"`
	// Historic Medians is the number of median historic prices to request from
	// the oracle module when evaluating new borrow positions containing this token.
	// All MsgBorrow, MsgWithdraw, and MsgDecollateralize must result in healthy
	// borrow positions under both current and historic prices. The default value of
	// zero for this field causes current price to be used in those calculations
	// for the affected Token.
	// The time span covered by the historic median will be:
	//
	//	oracle.Params.median_stamp_period * oracle.Params.historic_stamp_period * historic_medians.
	HistoricMedians uint32 `protobuf:"varint,19,opt,name=historic_medians,json=historicMedians,proto3" json:"historic_medians,omitempty" yaml:"historic_medians"`
}

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_8cb1bf9ea641ecc6, []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

// SpecialAssetPair defines a special (increased) CollateralWeight used when a specified Collateral is used
// to collateralize a specified Borrow. This association is one-way (so it does not work in reverse).
type SpecialAssetPair struct {
	// Collateral base token denom.
	Collateral string `protobuf:"bytes,1,opt,name=collateral,proto3" json:"collateral,omitempty"`
	// Borrow base token denom.
	Borrow string `protobuf:"bytes,2,opt,name=borrow,proto3" json:"borrow,omitempty"`
	// Collateral Weight defines what portion of the total value of the asset
	// can contribute to a users borrowing power. For special asset pairs, this
	// also overrides the borrowed asset's collateral weight when evaluating borrow
	// factor. Valid values: 0-1.
	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"`
	// Liquidation threshold defines what portion of the total value of the assets
	// can contribute to a users liquidation threshold, when borrowing within the pair.
	// Valid values in range [collateral_weight,1]
	LiquidationThreshold github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=liquidation_threshold,json=liquidationThreshold,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"liquidation_threshold"`
}

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

var xxx_messageInfo_SpecialAssetPair proto.InternalMessageInfo

// SpecialAssetSet defines a special (increased) CollateralWeight used when any of a set
// of assets are used to borrow each other (except for looping). It is used in gov proposals
// to create all the pairs that make up a set at once.
type SpecialAssetSet struct {
	// Collateral or borrowed base token denoms.
	Assets []string `protobuf:"bytes,1,rep,name=assets,proto3" json:"assets,omitempty"`
	// Collateral Weight defines what portion of the total value of the assets
	// can contribute to a users borrowing power, when borrowing within the set.
	// Valid values: 0-1.
	CollateralWeight github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=collateral_weight,json=collateralWeight,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"collateral_weight"`
	// Liquidation threshold defines what portion of the total value of the assets
	// can contribute to a users liquidation threshold, when borrowing within the set.
	// Valid values in range [collateral_weight,1]
	LiquidationThreshold github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=liquidation_threshold,json=liquidationThreshold,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"liquidation_threshold"`
}

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

var xxx_messageInfo_SpecialAssetSet proto.InternalMessageInfo

func init() {
	proto.RegisterType((*Params)(nil), "umee.leverage.v1.Params")
	proto.RegisterType((*Token)(nil), "umee.leverage.v1.Token")
	proto.RegisterType((*SpecialAssetPair)(nil), "umee.leverage.v1.SpecialAssetPair")
	proto.RegisterType((*SpecialAssetSet)(nil), "umee.leverage.v1.SpecialAssetSet")
}

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

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

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

	that1, ok := that.(*Params)
	if !ok {
		that2, ok := that.(Params)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.CompleteLiquidationThreshold.Equal(that1.CompleteLiquidationThreshold) {
		return false
	}
	if !this.MinimumCloseFactor.Equal(that1.MinimumCloseFactor) {
		return false
	}
	if !this.OracleRewardFactor.Equal(that1.OracleRewardFactor) {
		return false
	}
	if !this.SmallLiquidationSize.Equal(that1.SmallLiquidationSize) {
		return false
	}
	if !this.DirectLiquidationFee.Equal(that1.DirectLiquidationFee) {
		return false
	}
	return true
}
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.LiquidationThreshold.Equal(that1.LiquidationThreshold) {
		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.KinkUtilization.Equal(that1.KinkUtilization) {
		return false
	}
	if !this.LiquidationIncentive.Equal(that1.LiquidationIncentive) {
		return false
	}
	if this.SymbolDenom != that1.SymbolDenom {
		return false
	}
	if this.Exponent != that1.Exponent {
		return false
	}
	if this.EnableMsgSupply != that1.EnableMsgSupply {
		return false
	}
	if this.EnableMsgBorrow != that1.EnableMsgBorrow {
		return false
	}
	if this.Blacklist != that1.Blacklist {
		return false
	}
	if !this.MaxCollateralShare.Equal(that1.MaxCollateralShare) {
		return false
	}
	if !this.MaxSupplyUtilization.Equal(that1.MaxSupplyUtilization) {
		return false
	}
	if !this.MinCollateralLiquidity.Equal(that1.MinCollateralLiquidity) {
		return false
	}
	if !this.MaxSupply.Equal(that1.MaxSupply) {
		return false
	}
	if this.HistoricMedians != that1.HistoricMedians {
		return false
	}
	return true
}
func (this *SpecialAssetPair) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SpecialAssetPair)
	if !ok {
		that2, ok := that.(SpecialAssetPair)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Collateral != that1.Collateral {
		return false
	}
	if this.Borrow != that1.Borrow {
		return false
	}
	if !this.CollateralWeight.Equal(that1.CollateralWeight) {
		return false
	}
	if !this.LiquidationThreshold.Equal(that1.LiquidationThreshold) {
		return false
	}
	return true
}
func (this *SpecialAssetSet) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SpecialAssetSet)
	if !ok {
		that2, ok := that.(SpecialAssetSet)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Assets) != len(that1.Assets) {
		return false
	}
	for i := range this.Assets {
		if this.Assets[i] != that1.Assets[i] {
			return false
		}
	}
	if !this.CollateralWeight.Equal(that1.CollateralWeight) {
		return false
	}
	if !this.LiquidationThreshold.Equal(that1.LiquidationThreshold) {
		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.DirectLiquidationFee.Size()
		i -= size
		if _, err := m.DirectLiquidationFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size := m.SmallLiquidationSize.Size()
		i -= size
		if _, err := m.SmallLiquidationSize.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		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.HistoricMedians != 0 {
		i = encodeVarintLeverage(dAtA, i, uint64(m.HistoricMedians))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	{
		size := m.MaxSupply.Size()
		i -= size
		if _, err := m.MaxSupply.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x92
	{
		size := m.MinCollateralLiquidity.Size()
		i -= size
		if _, err := m.MinCollateralLiquidity.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x8a
	{
		size := m.MaxSupplyUtilization.Size()
		i -= size
		if _, err := m.MaxSupplyUtilization.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x82
	{
		size := m.MaxCollateralShare.Size()
		i -= size
		if _, err := m.MaxCollateralShare.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x7a
	if m.Blacklist {
		i--
		if m.Blacklist {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x70
	}
	if m.EnableMsgBorrow {
		i--
		if m.EnableMsgBorrow {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	if m.EnableMsgSupply {
		i--
		if m.EnableMsgSupply {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x60
	}
	if m.Exponent != 0 {
		i = encodeVarintLeverage(dAtA, i, uint64(m.Exponent))
		i--
		dAtA[i] = 0x58
	}
	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] = 0x52
	}
	{
		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] = 0x4a
	{
		size := m.KinkUtilization.Size()
		i -= size
		if _, err := m.KinkUtilization.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	{
		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] = 0x3a
	{
		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] = 0x32
	{
		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] = 0x2a
	{
		size := m.LiquidationThreshold.Size()
		i -= size
		if _, err := m.LiquidationThreshold.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 (m *SpecialAssetPair) 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 *SpecialAssetPair) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SpecialAssetPair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.LiquidationThreshold.Size()
		i -= size
		if _, err := m.LiquidationThreshold.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
	if len(m.Borrow) > 0 {
		i -= len(m.Borrow)
		copy(dAtA[i:], m.Borrow)
		i = encodeVarintLeverage(dAtA, i, uint64(len(m.Borrow)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Collateral) > 0 {
		i -= len(m.Collateral)
		copy(dAtA[i:], m.Collateral)
		i = encodeVarintLeverage(dAtA, i, uint64(len(m.Collateral)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SpecialAssetSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.LiquidationThreshold.Size()
		i -= size
		if _, err := m.LiquidationThreshold.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLeverage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		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] = 0x12
	if len(m.Assets) > 0 {
		for iNdEx := len(m.Assets) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Assets[iNdEx])
			copy(dAtA[i:], m.Assets[iNdEx])
			i = encodeVarintLeverage(dAtA, i, uint64(len(m.Assets[iNdEx])))
			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))
	l = m.SmallLiquidationSize.Size()
	n += 1 + l + sovLeverage(uint64(l))
	l = m.DirectLiquidationFee.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.LiquidationThreshold.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.KinkUtilization.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))
	}
	if m.EnableMsgSupply {
		n += 2
	}
	if m.EnableMsgBorrow {
		n += 2
	}
	if m.Blacklist {
		n += 2
	}
	l = m.MaxCollateralShare.Size()
	n += 1 + l + sovLeverage(uint64(l))
	l = m.MaxSupplyUtilization.Size()
	n += 2 + l + sovLeverage(uint64(l))
	l = m.MinCollateralLiquidity.Size()
	n += 2 + l + sovLeverage(uint64(l))
	l = m.MaxSupply.Size()
	n += 2 + l + sovLeverage(uint64(l))
	if m.HistoricMedians != 0 {
		n += 2 + sovLeverage(uint64(m.HistoricMedians))
	}
	return n
}

func (m *SpecialAssetPair) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Collateral)
	if l > 0 {
		n += 1 + l + sovLeverage(uint64(l))
	}
	l = len(m.Borrow)
	if l > 0 {
		n += 1 + l + sovLeverage(uint64(l))
	}
	l = m.CollateralWeight.Size()
	n += 1 + l + sovLeverage(uint64(l))
	l = m.LiquidationThreshold.Size()
	n += 1 + l + sovLeverage(uint64(l))
	return n
}

func (m *SpecialAssetSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Assets) > 0 {
		for _, s := range m.Assets {
			l = len(s)
			n += 1 + l + sovLeverage(uint64(l))
		}
	}
	l = m.CollateralWeight.Size()
	n += 1 + l + sovLeverage(uint64(l))
	l = m.LiquidationThreshold.Size()
	n += 1 + l + sovLeverage(uint64(l))
	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
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SmallLiquidationSize", 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.SmallLiquidationSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DirectLiquidationFee", 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.DirectLiquidationFee.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 LiquidationThreshold", 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.LiquidationThreshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			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 6:
			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 7:
			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 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KinkUtilization", 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.KinkUtilization.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			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 10:
			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 11:
			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
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableMsgSupply", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableMsgSupply = bool(v != 0)
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableMsgBorrow", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableMsgBorrow = bool(v != 0)
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Blacklist", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Blacklist = bool(v != 0)
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxCollateralShare", 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.MaxCollateralShare.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxSupplyUtilization", 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.MaxSupplyUtilization.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinCollateralLiquidity", 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.MinCollateralLiquidity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxSupply", 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.MaxSupply.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HistoricMedians", wireType)
			}
			m.HistoricMedians = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLeverage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HistoricMedians |= 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 (m *SpecialAssetPair) 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: SpecialAssetPair: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SpecialAssetPair: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Collateral", 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.Collateral = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Borrow", 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.Borrow = string(dAtA[iNdEx:postIndex])
			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 LiquidationThreshold", 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.LiquidationThreshold.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 *SpecialAssetSet) 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: SpecialAssetSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SpecialAssetSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Assets", 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.Assets = append(m.Assets, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			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 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LiquidationThreshold", 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.LiquidationThreshold.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 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")
)