metoken.pb.go

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

package metoken

import (
	cosmossdk_io_math "cosmossdk.io/math"
	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 metoken module.
type Params struct {
	// Reserves Re-balancing Frequency in seconds, determines how often the re-balancing of the module reserves will be
	// triggered
	RebalancingFrequency int64 `protobuf:"varint,1,opt,name=rebalancing_frequency,json=rebalancingFrequency,proto3" json:"rebalancing_frequency,omitempty"`
	// Interest claiming frequency in seconds, determines how often metoken module will claim accrued interest from
	// leverage module
	ClaimingFrequency int64 `protobuf:"varint,2,opt,name=claiming_frequency,json=claimingFrequency,proto3" json:"claiming_frequency,omitempty"`
}

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

func (m *Params) GetRebalancingFrequency() int64 {
	if m != nil {
		return m.RebalancingFrequency
	}
	return 0
}

func (m *Params) GetClaimingFrequency() int64 {
	if m != nil {
		return m.ClaimingFrequency
	}
	return 0
}

// Index defines an index of assets that are allowed to swap and redeem for the Index's meToken,
// along with its metadata and parameters.
type Index struct {
	// Denom is the denomination of the Index's meToken denom that will be given to user in exchange of accepted
	// assets.
	Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
	// MaxSupply is the maximum amount of Index's meTokens can be minted.
	// A swap that requires to mint more Index's meToken than this value will result in an error.
	// Must be a non negative value. 0 means that there is no limit.
	MaxSupply cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=max_supply,json=maxSupply,proto3,customtype=cosmossdk.io/math.Int" json:"max_supply"`
	// Exponent is the power of ten by which to multiply, in order to convert
	// an amount of the meToken for the exchange operations.
	// Valid value: must be the same as the oracle.Denom.exponent.
	Exponent uint32 `protobuf:"varint,3,opt,name=exponent,proto3" json:"exponent,omitempty"`
	// Fee contains fee parameters used for swap and redemption fee calculations for all underlying
	// assets in this index.
	Fee Fee `protobuf:"bytes,4,opt,name=fee,proto3" json:"fee"`
	// Accepted Assets is the list of underlying Tokens that can be swapped and redeemed for the Index's meToken,
	// along with their token-specific parameters.
	AcceptedAssets []AcceptedAsset `protobuf:"bytes,5,rep,name=accepted_assets,json=acceptedAssets,proto3" json:"accepted_assets"`
}

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

var xxx_messageInfo_Index proto.InternalMessageInfo

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

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

func (m *Index) GetFee() Fee {
	if m != nil {
		return m.Fee
	}
	return Fee{}
}

func (m *Index) GetAcceptedAssets() []AcceptedAsset {
	if m != nil {
		return m.AcceptedAssets
	}
	return nil
}

// Fee are the parameters used for the calculation of the fee to be applied for swaps and redemptions and charged to
// the user. The usage of these parameters is explained here:
// https://github.com/umee-network/umee/tree/main/x/metoken#dynamic-fee
type Fee struct {
	// Min fee is the minimum fee to be charged to the user. The applied fee will tend to decrease down to this value,
	// when the accepted asset is undersupplied in the index. It must be less than Balanced and Max fees.
	// Valid values: 0-1.
	MinFee github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=min_fee,json=minFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"min_fee"`
	// Balanced fee is the fee to be charged to the user when the index is balanced. It must be greater than min_fee and
	// lower than max_fee
	// Valid values: 0-1.
	BalancedFee github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=balanced_fee,json=balancedFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"balanced_fee"`
	// Max fee is the maximum fee to be charged to the user. The applied fee will tend to increase up to this value,
	// when the accepted asset is oversupplied in the index. It must be greater than Min and Balanced fee.
	// Valid values: 0-1.
	MaxFee github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=max_fee,json=maxFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_fee"`
}

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

var xxx_messageInfo_Fee proto.InternalMessageInfo

// AcceptedAsset is an asset that is accepted to participate in the Index's swaps and redemptions, along with its
// metadata and parameters
type AcceptedAsset struct {
	// Denom is the denomination of the underlying asset. Must be the base
	// denom as registered in the Bank module (so IBC denom for IBC tokens).
	Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
	// Reserve portion is the portion of swapped assets that will be kept in the metoken module as reserves,
	// instead of supplied to the leverage module. It is also the
	// portion that will be taken from metoken module reserves when a redemption occurs.
	// Valid values: 0-1.
	ReservePortion github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=reserve_portion,json=reservePortion,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"reserve_portion"`
	// Target allocation is the portion of an accepted asset the Index is targeting to have. The sum of
	// target allocations of every accepted asset in the Index should be equal to 1.
	// Valid values: 0-1.
	TargetAllocation github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=target_allocation,json=targetAllocation,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"target_allocation"`
}

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

var xxx_messageInfo_AcceptedAsset proto.InternalMessageInfo

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

// IndexPrices provides meToken price related index information.
type IndexPrices struct {
	// meToken denom.
	Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
	// Price in USD of one unit of meToken, expressed in decimals.
	Price github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=price,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"price"`
	// Exponent is the power of ten by which to multiply, in order to convert
	// an amount of the meToken for the exchange operations.
	Exponent uint32       `protobuf:"varint,3,opt,name=exponent,proto3" json:"exponent,omitempty"`
	Assets   []AssetPrice `protobuf:"bytes,4,rep,name=assets,proto3" json:"assets"`
}

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

var xxx_messageInfo_IndexPrices proto.InternalMessageInfo

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

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

func (m *IndexPrices) GetAssets() []AssetPrice {
	if m != nil {
		return m.Assets
	}
	return nil
}

// AssetPrice information related to the index operations.
type AssetPrice struct {
	BaseDenom   string `protobuf:"bytes,1,opt,name=base_denom,json=baseDenom,proto3" json:"base_denom,omitempty"`
	SymbolDenom string `protobuf:"bytes,2,opt,name=symbol_denom,json=symbolDenom,proto3" json:"symbol_denom,omitempty"`
	// Price in USD of one unit of asset, expressed in decimals.
	Price github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=price,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"price"`
	// Exponent is the power of ten by which to multiply, in order to convert
	// an amount of the asset for the exchange operations.
	Exponent uint32 `protobuf:"varint,4,opt,name=exponent,proto3" json:"exponent,omitempty"`
	// SwapRate used for exchange calculations asset -> meToken.
	SwapRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,5,opt,name=swap_rate,json=swapRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"swap_rate"`
	// RedeemRate used for exchange calculations meToken -> asset.
	RedeemRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=redeem_rate,json=redeemRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"redeem_rate"`
	// SwapFee charged to the user on a swap, expressed in fraction.
	// Valid values: 0-1.
	SwapFee github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,7,opt,name=swap_fee,json=swapFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"swap_fee"`
	// RedeemFee charged to the user on a redemption, expressed in fraction.
	// Valid values: 0-1.
	RedeemFee github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,8,opt,name=redeem_fee,json=redeemFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"redeem_fee"`
}

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

var xxx_messageInfo_AssetPrice proto.InternalMessageInfo

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

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

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

func init() {
	proto.RegisterType((*Params)(nil), "umee.metoken.v1.Params")
	proto.RegisterType((*Index)(nil), "umee.metoken.v1.Index")
	proto.RegisterType((*Fee)(nil), "umee.metoken.v1.Fee")
	proto.RegisterType((*AcceptedAsset)(nil), "umee.metoken.v1.AcceptedAsset")
	proto.RegisterType((*IndexPrices)(nil), "umee.metoken.v1.IndexPrices")
	proto.RegisterType((*AssetPrice)(nil), "umee.metoken.v1.AssetPrice")
}

func init() { proto.RegisterFile("umee/metoken/v1/metoken.proto", fileDescriptor_dda977db8ad52437) }

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

	that1, ok := that.(*Index)
	if !ok {
		that2, ok := that.(Index)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Denom != that1.Denom {
		return false
	}
	if !this.MaxSupply.Equal(that1.MaxSupply) {
		return false
	}
	if this.Exponent != that1.Exponent {
		return false
	}
	if !this.Fee.Equal(&that1.Fee) {
		return false
	}
	if len(this.AcceptedAssets) != len(that1.AcceptedAssets) {
		return false
	}
	for i := range this.AcceptedAssets {
		if !this.AcceptedAssets[i].Equal(&that1.AcceptedAssets[i]) {
			return false
		}
	}
	return true
}
func (this *Fee) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Fee)
	if !ok {
		that2, ok := that.(Fee)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.MinFee.Equal(that1.MinFee) {
		return false
	}
	if !this.BalancedFee.Equal(that1.BalancedFee) {
		return false
	}
	if !this.MaxFee.Equal(that1.MaxFee) {
		return false
	}
	return true
}
func (this *AcceptedAsset) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AcceptedAsset)
	if !ok {
		that2, ok := that.(AcceptedAsset)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Denom != that1.Denom {
		return false
	}
	if !this.ReservePortion.Equal(that1.ReservePortion) {
		return false
	}
	if !this.TargetAllocation.Equal(that1.TargetAllocation) {
		return false
	}
	return true
}
func (this *IndexPrices) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IndexPrices)
	if !ok {
		that2, ok := that.(IndexPrices)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Denom != that1.Denom {
		return false
	}
	if !this.Price.Equal(that1.Price) {
		return false
	}
	if this.Exponent != that1.Exponent {
		return false
	}
	if len(this.Assets) != len(that1.Assets) {
		return false
	}
	for i := range this.Assets {
		if !this.Assets[i].Equal(&that1.Assets[i]) {
			return false
		}
	}
	return true
}
func (this *AssetPrice) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AssetPrice)
	if !ok {
		that2, ok := that.(AssetPrice)
		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.SymbolDenom != that1.SymbolDenom {
		return false
	}
	if !this.Price.Equal(that1.Price) {
		return false
	}
	if this.Exponent != that1.Exponent {
		return false
	}
	if !this.SwapRate.Equal(that1.SwapRate) {
		return false
	}
	if !this.RedeemRate.Equal(that1.RedeemRate) {
		return false
	}
	if !this.SwapFee.Equal(that1.SwapFee) {
		return false
	}
	if !this.RedeemFee.Equal(that1.RedeemFee) {
		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
	if m.ClaimingFrequency != 0 {
		i = encodeVarintMetoken(dAtA, i, uint64(m.ClaimingFrequency))
		i--
		dAtA[i] = 0x10
	}
	if m.RebalancingFrequency != 0 {
		i = encodeVarintMetoken(dAtA, i, uint64(m.RebalancingFrequency))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Index) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AcceptedAssets) > 0 {
		for iNdEx := len(m.AcceptedAssets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AcceptedAssets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetoken(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	{
		size, err := m.Fee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMetoken(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.Exponent != 0 {
		i = encodeVarintMetoken(dAtA, i, uint64(m.Exponent))
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.MaxSupply.Size()
		i -= size
		if _, err := m.MaxSupply.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetoken(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintMetoken(dAtA, i, uint64(len(m.Denom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Fee) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.MaxFee.Size()
		i -= size
		if _, err := m.MaxFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetoken(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.BalancedFee.Size()
		i -= size
		if _, err := m.BalancedFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetoken(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.MinFee.Size()
		i -= size
		if _, err := m.MinFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetoken(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *AcceptedAsset) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.TargetAllocation.Size()
		i -= size
		if _, err := m.TargetAllocation.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetoken(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.ReservePortion.Size()
		i -= size
		if _, err := m.ReservePortion.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetoken(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintMetoken(dAtA, i, uint64(len(m.Denom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *IndexPrices) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Assets) > 0 {
		for iNdEx := len(m.Assets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Assets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetoken(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Exponent != 0 {
		i = encodeVarintMetoken(dAtA, i, uint64(m.Exponent))
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.Price.Size()
		i -= size
		if _, err := m.Price.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetoken(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintMetoken(dAtA, i, uint64(len(m.Denom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AssetPrice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.RedeemFee.Size()
		i -= size
		if _, err := m.RedeemFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetoken(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	{
		size := m.SwapFee.Size()
		i -= size
		if _, err := m.SwapFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetoken(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size := m.RedeemRate.Size()
		i -= size
		if _, err := m.RedeemRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetoken(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size := m.SwapRate.Size()
		i -= size
		if _, err := m.SwapRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetoken(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.Exponent != 0 {
		i = encodeVarintMetoken(dAtA, i, uint64(m.Exponent))
		i--
		dAtA[i] = 0x20
	}
	{
		size := m.Price.Size()
		i -= size
		if _, err := m.Price.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetoken(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.SymbolDenom) > 0 {
		i -= len(m.SymbolDenom)
		copy(dAtA[i:], m.SymbolDenom)
		i = encodeVarintMetoken(dAtA, i, uint64(len(m.SymbolDenom)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.BaseDenom) > 0 {
		i -= len(m.BaseDenom)
		copy(dAtA[i:], m.BaseDenom)
		i = encodeVarintMetoken(dAtA, i, uint64(len(m.BaseDenom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintMetoken(dAtA []byte, offset int, v uint64) int {
	offset -= sovMetoken(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
	if m.RebalancingFrequency != 0 {
		n += 1 + sovMetoken(uint64(m.RebalancingFrequency))
	}
	if m.ClaimingFrequency != 0 {
		n += 1 + sovMetoken(uint64(m.ClaimingFrequency))
	}
	return n
}

func (m *Index) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Denom)
	if l > 0 {
		n += 1 + l + sovMetoken(uint64(l))
	}
	l = m.MaxSupply.Size()
	n += 1 + l + sovMetoken(uint64(l))
	if m.Exponent != 0 {
		n += 1 + sovMetoken(uint64(m.Exponent))
	}
	l = m.Fee.Size()
	n += 1 + l + sovMetoken(uint64(l))
	if len(m.AcceptedAssets) > 0 {
		for _, e := range m.AcceptedAssets {
			l = e.Size()
			n += 1 + l + sovMetoken(uint64(l))
		}
	}
	return n
}

func (m *Fee) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MinFee.Size()
	n += 1 + l + sovMetoken(uint64(l))
	l = m.BalancedFee.Size()
	n += 1 + l + sovMetoken(uint64(l))
	l = m.MaxFee.Size()
	n += 1 + l + sovMetoken(uint64(l))
	return n
}

func (m *AcceptedAsset) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Denom)
	if l > 0 {
		n += 1 + l + sovMetoken(uint64(l))
	}
	l = m.ReservePortion.Size()
	n += 1 + l + sovMetoken(uint64(l))
	l = m.TargetAllocation.Size()
	n += 1 + l + sovMetoken(uint64(l))
	return n
}

func (m *IndexPrices) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Denom)
	if l > 0 {
		n += 1 + l + sovMetoken(uint64(l))
	}
	l = m.Price.Size()
	n += 1 + l + sovMetoken(uint64(l))
	if m.Exponent != 0 {
		n += 1 + sovMetoken(uint64(m.Exponent))
	}
	if len(m.Assets) > 0 {
		for _, e := range m.Assets {
			l = e.Size()
			n += 1 + l + sovMetoken(uint64(l))
		}
	}
	return n
}

func (m *AssetPrice) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BaseDenom)
	if l > 0 {
		n += 1 + l + sovMetoken(uint64(l))
	}
	l = len(m.SymbolDenom)
	if l > 0 {
		n += 1 + l + sovMetoken(uint64(l))
	}
	l = m.Price.Size()
	n += 1 + l + sovMetoken(uint64(l))
	if m.Exponent != 0 {
		n += 1 + sovMetoken(uint64(m.Exponent))
	}
	l = m.SwapRate.Size()
	n += 1 + l + sovMetoken(uint64(l))
	l = m.RedeemRate.Size()
	n += 1 + l + sovMetoken(uint64(l))
	l = m.SwapFee.Size()
	n += 1 + l + sovMetoken(uint64(l))
	l = m.RedeemFee.Size()
	n += 1 + l + sovMetoken(uint64(l))
	return n
}

func sovMetoken(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMetoken(x uint64) (n int) {
	return sovMetoken(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 ErrIntOverflowMetoken
			}
			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 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RebalancingFrequency", wireType)
			}
			m.RebalancingFrequency = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RebalancingFrequency |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClaimingFrequency", wireType)
			}
			m.ClaimingFrequency = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ClaimingFrequency |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetoken(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetoken
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Index) 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 ErrIntOverflowMetoken
			}
			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: Index: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Index: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Denom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MaxSupply.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowMetoken
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Exponent |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AcceptedAssets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AcceptedAssets = append(m.AcceptedAssets, AcceptedAsset{})
			if err := m.AcceptedAssets[len(m.AcceptedAssets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetoken(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetoken
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Fee) 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 ErrIntOverflowMetoken
			}
			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: Fee: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fee: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BalancedFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BalancedFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MaxFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetoken(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetoken
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AcceptedAsset) 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 ErrIntOverflowMetoken
			}
			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: AcceptedAsset: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AcceptedAsset: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Denom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReservePortion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ReservePortion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetAllocation", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TargetAllocation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetoken(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetoken
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IndexPrices) 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 ErrIntOverflowMetoken
			}
			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: IndexPrices: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IndexPrices: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Denom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Price.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowMetoken
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Exponent |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Assets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Assets = append(m.Assets, AssetPrice{})
			if err := m.Assets[len(m.Assets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetoken(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetoken
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AssetPrice) 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 ErrIntOverflowMetoken
			}
			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: AssetPrice: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AssetPrice: 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 ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			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 SymbolDenom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SymbolDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Price.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowMetoken
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Exponent |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SwapRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SwapRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedeemRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RedeemRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SwapFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SwapFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedeemFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetoken
				}
				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 ErrInvalidLengthMetoken
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetoken
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RedeemFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetoken(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetoken
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthMetoken        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMetoken          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMetoken = fmt.Errorf("proto: unexpected end of group")
)