marketmaker.pb.go

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

package types

import (
	fmt "fmt"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "github.com/regen-network/cosmos-proto"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

// 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 set of params for the marketmaker module.
type Params struct {
	// Address containing the funds used to distribute incentives
	IncentiveBudgetAddress string `protobuf:"bytes,1,opt,name=incentive_budget_address,json=incentiveBudgetAddress,proto3" json:"incentive_budget_address,omitempty" yaml:"incentive_budget_address"`
	// The amount of deposit to be applied to the market maker, which is calculated per pair and is refunded when the
	// market maker included or rejected through the MarketMaker Proposal
	DepositAmount github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=deposit_amount,json=depositAmount,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"deposit_amount" yaml:"deposit_amount"`
	// Common variables used in market maker scoring system
	Common Common `protobuf:"bytes,3,opt,name=common,proto3" json:"common" yaml:"common"`
	// Include the pairs that are incentive target pairs and the variables used in market maker scoring system
	IncentivePairs []IncentivePair `protobuf:"bytes,4,rep,name=incentive_pairs,json=incentivePairs,proto3" json:"incentive_pairs" yaml:"incentive_pairs"`
}

func (m *Params) Reset()      { *m = Params{} }
func (*Params) ProtoMessage() {}
func (*Params) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f7925828ae7cdf, []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

type Common struct {
	// Minimum ratio to maintain the tick order
	MinOpenRatio github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=min_open_ratio,json=minOpenRatio,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"min_open_ratio" yaml:"min_open_ratio"`
	// Minimum ratio of open amount to MinDepth
	MinOpenDepthRatio github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=min_open_depth_ratio,json=minOpenDepthRatio,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"min_open_depth_ratio" yaml:"min_open_depth_ratio"`
	// Maximum allowable consecutive blocks of outage
	MaxDowntime uint32 `protobuf:"varint,3,opt,name=max_downtime,json=maxDowntime,proto3" json:"max_downtime,omitempty" yaml:"max_downtime"`
	// Maximum allowable sum of blocks in an hour
	MaxTotalDowntime uint32 `protobuf:"varint,4,opt,name=max_total_downtime,json=maxTotalDowntime,proto3" json:"max_total_downtime,omitempty" yaml:"max_total_downtime"`
	// Minimum value of LiveHour to achieve LiveDay
	MinHours uint32 `protobuf:"varint,5,opt,name=min_hours,json=minHours,proto3" json:"min_hours,omitempty" yaml:"min_hours"`
	// Minimum value of LiveDay to maintain MM eligibility
	MinDays uint32 `protobuf:"varint,6,opt,name=min_days,json=minDays,proto3" json:"min_days,omitempty" yaml:"min_days"`
}

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

var xxx_messageInfo_Common proto.InternalMessageInfo

type IncentivePair struct {
	// Pair id of liquidity module
	PairId uint64 `protobuf:"varint,1,opt,name=pair_id,json=pairId,proto3" json:"pair_id,omitempty" yaml:"pair_id"`
	// Time the pair variables start to be applied to the scoring system
	UpdateTime time.Time `protobuf:"bytes,2,opt,name=update_time,json=updateTime,proto3,stdtime" json:"update_time" yaml:"update_time"`
	// Incentive weights for each pair
	IncentiveWeight github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=incentive_weight,json=incentiveWeight,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"incentive_weight" yaml:"incentive_weight"`
	// Maximum allowable spread between bid and ask
	MaxSpread github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=max_spread,json=maxSpread,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_spread" yaml:"max_spread"`
	// Minimum allowable price difference of high and low on both side of orders
	MinWidth github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,5,opt,name=min_width,json=minWidth,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"min_width" yaml:"min_width"`
	// Minimum allowable order depth on each side
	MinDepth github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,6,opt,name=min_depth,json=minDepth,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_depth" yaml:"min_depth"`
}

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

var xxx_messageInfo_IncentivePair proto.InternalMessageInfo

// Store the total amount of incentives distributed through `MarketMakerProposal`, and it can be claimed at once through
// `MsgClaimIncentives`
type Incentive struct {
	Address   string                                   `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty" yaml:"address"`
	Claimable github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=claimable,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"claimable" yaml:"claimable"`
}

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

var xxx_messageInfo_Incentive proto.InternalMessageInfo

// Market maker object created by applying, if included through `MarketMakerProposal`, eligible becomes true and is
// deleted if rejected or excluded
type MarketMaker struct {
	Address  string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty" yaml:"address"`
	PairId   uint64 `protobuf:"varint,2,opt,name=pair_id,json=pairId,proto3" json:"pair_id,omitempty" yaml:"pair_id"`
	Eligible bool   `protobuf:"varint,3,opt,name=eligible,proto3" json:"eligible,omitempty" yaml:"eligible"`
}

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

var xxx_messageInfo_MarketMaker proto.InternalMessageInfo

// stores apply deposit amount for a future refund
type Deposit struct {
	Amount github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=amount,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"amount" yaml:"amount"`
}

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

var xxx_messageInfo_Deposit proto.InternalMessageInfo

type DepositRecord struct {
	Address string                                   `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty" yaml:"address"`
	PairId  uint64                                   `protobuf:"varint,2,opt,name=pair_id,json=pairId,proto3" json:"pair_id,omitempty" yaml:"pair_id"`
	Amount  github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,3,rep,name=amount,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"amount" yaml:"amount"`
}

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

var xxx_messageInfo_DepositRecord proto.InternalMessageInfo

func init() {
	proto.RegisterType((*Params)(nil), "crescent.marketmaker.v1beta1.Params")
	proto.RegisterType((*Common)(nil), "crescent.marketmaker.v1beta1.Common")
	proto.RegisterType((*IncentivePair)(nil), "crescent.marketmaker.v1beta1.IncentivePair")
	proto.RegisterType((*Incentive)(nil), "crescent.marketmaker.v1beta1.Incentive")
	proto.RegisterType((*MarketMaker)(nil), "crescent.marketmaker.v1beta1.MarketMaker")
	proto.RegisterType((*Deposit)(nil), "crescent.marketmaker.v1beta1.Deposit")
	proto.RegisterType((*DepositRecord)(nil), "crescent.marketmaker.v1beta1.DepositRecord")
}

func init() {
	proto.RegisterFile("crescent/marketmaker/v1beta1/marketmaker.proto", fileDescriptor_76f7925828ae7cdf)
}

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

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 len(m.IncentivePairs) > 0 {
		for iNdEx := len(m.IncentivePairs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.IncentivePairs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMarketmaker(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	{
		size, err := m.Common.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMarketmaker(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.DepositAmount) > 0 {
		for iNdEx := len(m.DepositAmount) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DepositAmount[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMarketmaker(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.IncentiveBudgetAddress) > 0 {
		i -= len(m.IncentiveBudgetAddress)
		copy(dAtA[i:], m.IncentiveBudgetAddress)
		i = encodeVarintMarketmaker(dAtA, i, uint64(len(m.IncentiveBudgetAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Common) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MinDays != 0 {
		i = encodeVarintMarketmaker(dAtA, i, uint64(m.MinDays))
		i--
		dAtA[i] = 0x30
	}
	if m.MinHours != 0 {
		i = encodeVarintMarketmaker(dAtA, i, uint64(m.MinHours))
		i--
		dAtA[i] = 0x28
	}
	if m.MaxTotalDowntime != 0 {
		i = encodeVarintMarketmaker(dAtA, i, uint64(m.MaxTotalDowntime))
		i--
		dAtA[i] = 0x20
	}
	if m.MaxDowntime != 0 {
		i = encodeVarintMarketmaker(dAtA, i, uint64(m.MaxDowntime))
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.MinOpenDepthRatio.Size()
		i -= size
		if _, err := m.MinOpenDepthRatio.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMarketmaker(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.MinOpenRatio.Size()
		i -= size
		if _, err := m.MinOpenRatio.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMarketmaker(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *IncentivePair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.MinDepth.Size()
		i -= size
		if _, err := m.MinDepth.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMarketmaker(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size := m.MinWidth.Size()
		i -= size
		if _, err := m.MinWidth.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMarketmaker(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.MaxSpread.Size()
		i -= size
		if _, err := m.MaxSpread.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMarketmaker(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.IncentiveWeight.Size()
		i -= size
		if _, err := m.IncentiveWeight.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMarketmaker(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdateTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateTime):])
	if err2 != nil {
		return 0, err2
	}
	i -= n2
	i = encodeVarintMarketmaker(dAtA, i, uint64(n2))
	i--
	dAtA[i] = 0x12
	if m.PairId != 0 {
		i = encodeVarintMarketmaker(dAtA, i, uint64(m.PairId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Incentive) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Claimable) > 0 {
		for iNdEx := len(m.Claimable) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Claimable[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMarketmaker(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintMarketmaker(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MarketMaker) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Eligible {
		i--
		if m.Eligible {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.PairId != 0 {
		i = encodeVarintMarketmaker(dAtA, i, uint64(m.PairId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintMarketmaker(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Deposit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Amount) > 0 {
		for iNdEx := len(m.Amount) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Amount[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMarketmaker(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *DepositRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Amount) > 0 {
		for iNdEx := len(m.Amount) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Amount[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMarketmaker(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.PairId != 0 {
		i = encodeVarintMarketmaker(dAtA, i, uint64(m.PairId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintMarketmaker(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintMarketmaker(dAtA []byte, offset int, v uint64) int {
	offset -= sovMarketmaker(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 = len(m.IncentiveBudgetAddress)
	if l > 0 {
		n += 1 + l + sovMarketmaker(uint64(l))
	}
	if len(m.DepositAmount) > 0 {
		for _, e := range m.DepositAmount {
			l = e.Size()
			n += 1 + l + sovMarketmaker(uint64(l))
		}
	}
	l = m.Common.Size()
	n += 1 + l + sovMarketmaker(uint64(l))
	if len(m.IncentivePairs) > 0 {
		for _, e := range m.IncentivePairs {
			l = e.Size()
			n += 1 + l + sovMarketmaker(uint64(l))
		}
	}
	return n
}

func (m *Common) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MinOpenRatio.Size()
	n += 1 + l + sovMarketmaker(uint64(l))
	l = m.MinOpenDepthRatio.Size()
	n += 1 + l + sovMarketmaker(uint64(l))
	if m.MaxDowntime != 0 {
		n += 1 + sovMarketmaker(uint64(m.MaxDowntime))
	}
	if m.MaxTotalDowntime != 0 {
		n += 1 + sovMarketmaker(uint64(m.MaxTotalDowntime))
	}
	if m.MinHours != 0 {
		n += 1 + sovMarketmaker(uint64(m.MinHours))
	}
	if m.MinDays != 0 {
		n += 1 + sovMarketmaker(uint64(m.MinDays))
	}
	return n
}

func (m *IncentivePair) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PairId != 0 {
		n += 1 + sovMarketmaker(uint64(m.PairId))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateTime)
	n += 1 + l + sovMarketmaker(uint64(l))
	l = m.IncentiveWeight.Size()
	n += 1 + l + sovMarketmaker(uint64(l))
	l = m.MaxSpread.Size()
	n += 1 + l + sovMarketmaker(uint64(l))
	l = m.MinWidth.Size()
	n += 1 + l + sovMarketmaker(uint64(l))
	l = m.MinDepth.Size()
	n += 1 + l + sovMarketmaker(uint64(l))
	return n
}

func (m *Incentive) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovMarketmaker(uint64(l))
	}
	if len(m.Claimable) > 0 {
		for _, e := range m.Claimable {
			l = e.Size()
			n += 1 + l + sovMarketmaker(uint64(l))
		}
	}
	return n
}

func (m *MarketMaker) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovMarketmaker(uint64(l))
	}
	if m.PairId != 0 {
		n += 1 + sovMarketmaker(uint64(m.PairId))
	}
	if m.Eligible {
		n += 2
	}
	return n
}

func (m *Deposit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Amount) > 0 {
		for _, e := range m.Amount {
			l = e.Size()
			n += 1 + l + sovMarketmaker(uint64(l))
		}
	}
	return n
}

func (m *DepositRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovMarketmaker(uint64(l))
	}
	if m.PairId != 0 {
		n += 1 + sovMarketmaker(uint64(m.PairId))
	}
	if len(m.Amount) > 0 {
		for _, e := range m.Amount {
			l = e.Size()
			n += 1 + l + sovMarketmaker(uint64(l))
		}
	}
	return n
}

func sovMarketmaker(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMarketmaker(x uint64) (n int) {
	return sovMarketmaker(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 ErrIntOverflowMarketmaker
			}
			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 != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IncentiveBudgetAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				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 ErrInvalidLengthMarketmaker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IncentiveBudgetAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DepositAmount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMarketmaker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DepositAmount = append(m.DepositAmount, types.Coin{})
			if err := m.DepositAmount[len(m.DepositAmount)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Common", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMarketmaker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Common.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IncentivePairs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMarketmaker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IncentivePairs = append(m.IncentivePairs, IncentivePair{})
			if err := m.IncentivePairs[len(m.IncentivePairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMarketmaker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Common) 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 ErrIntOverflowMarketmaker
			}
			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: Common: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Common: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinOpenRatio", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				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 ErrInvalidLengthMarketmaker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinOpenRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinOpenDepthRatio", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				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 ErrInvalidLengthMarketmaker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinOpenDepthRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxDowntime", wireType)
			}
			m.MaxDowntime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxDowntime |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxTotalDowntime", wireType)
			}
			m.MaxTotalDowntime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxTotalDowntime |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinHours", wireType)
			}
			m.MinHours = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinHours |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinDays", wireType)
			}
			m.MinDays = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinDays |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMarketmaker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IncentivePair) 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 ErrIntOverflowMarketmaker
			}
			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: IncentivePair: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IncentivePair: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PairId", wireType)
			}
			m.PairId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PairId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMarketmaker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdateTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IncentiveWeight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				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 ErrInvalidLengthMarketmaker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.IncentiveWeight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxSpread", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				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 ErrInvalidLengthMarketmaker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MaxSpread.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinWidth", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				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 ErrInvalidLengthMarketmaker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinWidth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinDepth", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				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 ErrInvalidLengthMarketmaker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinDepth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMarketmaker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Incentive) 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 ErrIntOverflowMarketmaker
			}
			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: Incentive: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Incentive: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				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 ErrInvalidLengthMarketmaker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Claimable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMarketmaker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Claimable = append(m.Claimable, types.Coin{})
			if err := m.Claimable[len(m.Claimable)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMarketmaker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MarketMaker) 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 ErrIntOverflowMarketmaker
			}
			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: MarketMaker: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MarketMaker: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				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 ErrInvalidLengthMarketmaker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PairId", wireType)
			}
			m.PairId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PairId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Eligible", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMarketmaker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Eligible = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipMarketmaker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMarketmaker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

var (
	ErrInvalidLengthMarketmaker        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMarketmaker          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMarketmaker = fmt.Errorf("proto: unexpected end of group")
)