genesis.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: injective/exchange/v1beta1/genesis.proto

package types

import (
	fmt "fmt"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// GenesisState defines the exchange module's genesis state.
type GenesisState struct {
	// params defines all the parameters of related to exchange.
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
	// spot_markets is an array containing the genesis trade pairs
	SpotMarkets []*SpotMarket `protobuf:"bytes,2,rep,name=spot_markets,json=spotMarkets,proto3" json:"spot_markets,omitempty"`
	// derivative_markets is an array containing the genesis derivative markets
	DerivativeMarkets []*DerivativeMarket `protobuf:"bytes,3,rep,name=derivative_markets,json=derivativeMarkets,proto3" json:"derivative_markets,omitempty"`
	// spot_orderbook defines the spot exchange limit orderbook active at genesis.
	SpotOrderbook []SpotOrderBook `protobuf:"bytes,4,rep,name=spot_orderbook,json=spotOrderbook,proto3" json:"spot_orderbook"`
	// derivative_orderbook defines the derivative exchange limit orderbook active at genesis.
	DerivativeOrderbook []DerivativeOrderBook `protobuf:"bytes,5,rep,name=derivative_orderbook,json=derivativeOrderbook,proto3" json:"derivative_orderbook"`
	// balances defines the exchange users balances active at genesis.
	Balances []Balance `protobuf:"bytes,6,rep,name=balances,proto3" json:"balances"`
	// positions defines the exchange derivative positions at genesis
	Positions []DerivativePosition `protobuf:"bytes,7,rep,name=positions,proto3" json:"positions"`
	// subaccount_trade_nonces defines the subaccount trade nonces for the subaccounts at genesis
	SubaccountTradeNonces []SubaccountNonce `protobuf:"bytes,8,rep,name=subaccount_trade_nonces,json=subaccountTradeNonces,proto3" json:"subaccount_trade_nonces"`
	// expiry_futures_market_info defines the market info for the expiry futures markets at genesis
	ExpiryFuturesMarketInfoState []ExpiryFuturesMarketInfoState `protobuf:"bytes,9,rep,name=expiry_futures_market_info_state,json=expiryFuturesMarketInfoState,proto3" json:"expiry_futures_market_info_state"`
	// perpetual_market_info defines the market info for the perpetual derivative markets at genesis
	PerpetualMarketInfo []PerpetualMarketInfo `protobuf:"bytes,10,rep,name=perpetual_market_info,json=perpetualMarketInfo,proto3" json:"perpetual_market_info"`
	// perpetual_market_funding_state defines the funding state for the perpetual derivative markets at genesis
	PerpetualMarketFundingState []PerpetualMarketFundingState `protobuf:"bytes,11,rep,name=perpetual_market_funding_state,json=perpetualMarketFundingState,proto3" json:"perpetual_market_funding_state"`
	// derivative_market_settlement_scheduled defines the scheduled markets for settlement at genesis
	DerivativeMarketSettlementScheduled []DerivativeMarketSettlementInfo `protobuf:"bytes,12,rep,name=derivative_market_settlement_scheduled,json=derivativeMarketSettlementScheduled,proto3" json:"derivative_market_settlement_scheduled"`
	// sets spot markets as enabled
	IsSpotExchangeEnabled bool `protobuf:"varint,13,opt,name=is_spot_exchange_enabled,json=isSpotExchangeEnabled,proto3" json:"is_spot_exchange_enabled,omitempty"`
	// sets derivative markets as enabled
	IsDerivativesExchangeEnabled bool `protobuf:"varint,14,opt,name=is_derivatives_exchange_enabled,json=isDerivativesExchangeEnabled,proto3" json:"is_derivatives_exchange_enabled,omitempty"`
	// the current trading reward campaign info
	TradingRewardCampaignInfo *TradingRewardCampaignInfo `protobuf:"bytes,15,opt,name=trading_reward_campaign_info,json=tradingRewardCampaignInfo,proto3" json:"trading_reward_campaign_info,omitempty"`
	// the current and upcoming trading reward campaign pools
	TradingRewardPoolCampaignSchedule []*CampaignRewardPool `protobuf:"bytes,16,rep,name=trading_reward_pool_campaign_schedule,json=tradingRewardPoolCampaignSchedule,proto3" json:"trading_reward_pool_campaign_schedule,omitempty"`
	// the current trading reward account points
	TradingRewardCampaignAccountPoints []*TradingRewardCampaignAccountPoints `protobuf:"bytes,17,rep,name=trading_reward_campaign_account_points,json=tradingRewardCampaignAccountPoints,proto3" json:"trading_reward_campaign_account_points,omitempty"`
	// the fee discount schedule
	FeeDiscountSchedule *FeeDiscountSchedule `protobuf:"bytes,18,opt,name=fee_discount_schedule,json=feeDiscountSchedule,proto3" json:"fee_discount_schedule,omitempty"`
	// the cached fee discount account tiers with TTL
	FeeDiscountAccountTierTtl []*FeeDiscountAccountTierTTL `protobuf:"bytes,19,rep,name=fee_discount_account_tier_ttl,json=feeDiscountAccountTierTtl,proto3" json:"fee_discount_account_tier_ttl,omitempty"`
	// the fee discount paid by accounts in all buckets
	FeeDiscountBucketVolumeAccounts []*FeeDiscountBucketVolumeAccounts `protobuf:"bytes,20,rep,name=fee_discount_bucket_volume_accounts,json=feeDiscountBucketVolumeAccounts,proto3" json:"fee_discount_bucket_volume_accounts,omitempty"`
	// sets the first fee cycle as finished
	IsFirstFeeCycleFinished bool `protobuf:"varint,21,opt,name=is_first_fee_cycle_finished,json=isFirstFeeCycleFinished,proto3" json:"is_first_fee_cycle_finished,omitempty"`
	// the current and upcoming trading reward campaign pending pools
	PendingTradingRewardPoolCampaignSchedule []*CampaignRewardPool `protobuf:"bytes,22,rep,name=pending_trading_reward_pool_campaign_schedule,json=pendingTradingRewardPoolCampaignSchedule,proto3" json:"pending_trading_reward_pool_campaign_schedule,omitempty"`
	// the pending trading reward account points
	PendingTradingRewardCampaignAccountPoints []*TradingRewardCampaignAccountPendingPoints `protobuf:"bytes,23,rep,name=pending_trading_reward_campaign_account_points,json=pendingTradingRewardCampaignAccountPoints,proto3" json:"pending_trading_reward_campaign_account_points,omitempty"`
	// the addresses opting out of trading rewards
	RewardsOptOutAddresses []string        `protobuf:"bytes,24,rep,name=rewards_opt_out_addresses,json=rewardsOptOutAddresses,proto3" json:"rewards_opt_out_addresses,omitempty"`
	HistoricalTradeRecords []*TradeRecords `protobuf:"bytes,25,rep,name=historical_trade_records,json=historicalTradeRecords,proto3" json:"historical_trade_records,omitempty"`
	// binary_options_markets is an array containing the genesis binary options markets
	BinaryOptionsMarkets []*BinaryOptionsMarket `protobuf:"bytes,26,rep,name=binary_options_markets,json=binaryOptionsMarkets,proto3" json:"binary_options_markets,omitempty"`
	// binary_options_markets_scheduled_for_settlement contains the marketIDs of binary options markets scheduled for next-block settlement
	BinaryOptionsMarketIdsScheduledForSettlement []string `protobuf:"bytes,27,rep,name=binary_options_market_ids_scheduled_for_settlement,json=binaryOptionsMarketIdsScheduledForSettlement,proto3" json:"binary_options_market_ids_scheduled_for_settlement,omitempty"`
	// spot_market_ids_scheduled_to_force_close defines the scheduled markets for forced closings at genesis
	SpotMarketIdsScheduledToForceClose []string `protobuf:"bytes,28,rep,name=spot_market_ids_scheduled_to_force_close,json=spotMarketIdsScheduledToForceClose,proto3" json:"spot_market_ids_scheduled_to_force_close,omitempty"`
	// denom_decimals defines the denom decimals for the exchange.
	DenomDecimals []DenomDecimals `protobuf:"bytes,29,rep,name=denom_decimals,json=denomDecimals,proto3" json:"denom_decimals"`
	// conditional_derivative_orderbook contains conditional orderbooks for all markets (both lmit and market conditional orders)
	ConditionalDerivativeOrderbooks []*ConditionalDerivativeOrderBook `protobuf:"bytes,30,rep,name=conditional_derivative_orderbooks,json=conditionalDerivativeOrderbooks,proto3" json:"conditional_derivative_orderbooks,omitempty"`
	// market_fee_multipliers contains any non-default atomic order fee multipliers
	MarketFeeMultipliers []*MarketFeeMultiplier             `protobuf:"bytes,31,rep,name=market_fee_multipliers,json=marketFeeMultipliers,proto3" json:"market_fee_multipliers,omitempty"`
	OrderbookSequences   []*OrderbookSequence               `protobuf:"bytes,32,rep,name=orderbook_sequences,json=orderbookSequences,proto3" json:"orderbook_sequences,omitempty"`
	SubaccountVolumes    []*AggregateSubaccountVolumeRecord `protobuf:"bytes,33,rep,name=subaccount_volumes,json=subaccountVolumes,proto3" json:"subaccount_volumes,omitempty"`
	MarketVolumes        []*MarketVolume                    `protobuf:"bytes,34,rep,name=market_volumes,json=marketVolumes,proto3" json:"market_volumes,omitempty"`
}

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

var xxx_messageInfo_GenesisState proto.InternalMessageInfo

func (m *GenesisState) GetParams() Params {
	if m != nil {
		return m.Params
	}
	return Params{}
}

func (m *GenesisState) GetSpotMarkets() []*SpotMarket {
	if m != nil {
		return m.SpotMarkets
	}
	return nil
}

func (m *GenesisState) GetDerivativeMarkets() []*DerivativeMarket {
	if m != nil {
		return m.DerivativeMarkets
	}
	return nil
}

func (m *GenesisState) GetSpotOrderbook() []SpotOrderBook {
	if m != nil {
		return m.SpotOrderbook
	}
	return nil
}

func (m *GenesisState) GetDerivativeOrderbook() []DerivativeOrderBook {
	if m != nil {
		return m.DerivativeOrderbook
	}
	return nil
}

func (m *GenesisState) GetBalances() []Balance {
	if m != nil {
		return m.Balances
	}
	return nil
}

func (m *GenesisState) GetPositions() []DerivativePosition {
	if m != nil {
		return m.Positions
	}
	return nil
}

func (m *GenesisState) GetSubaccountTradeNonces() []SubaccountNonce {
	if m != nil {
		return m.SubaccountTradeNonces
	}
	return nil
}

func (m *GenesisState) GetExpiryFuturesMarketInfoState() []ExpiryFuturesMarketInfoState {
	if m != nil {
		return m.ExpiryFuturesMarketInfoState
	}
	return nil
}

func (m *GenesisState) GetPerpetualMarketInfo() []PerpetualMarketInfo {
	if m != nil {
		return m.PerpetualMarketInfo
	}
	return nil
}

func (m *GenesisState) GetPerpetualMarketFundingState() []PerpetualMarketFundingState {
	if m != nil {
		return m.PerpetualMarketFundingState
	}
	return nil
}

func (m *GenesisState) GetDerivativeMarketSettlementScheduled() []DerivativeMarketSettlementInfo {
	if m != nil {
		return m.DerivativeMarketSettlementScheduled
	}
	return nil
}

func (m *GenesisState) GetIsSpotExchangeEnabled() bool {
	if m != nil {
		return m.IsSpotExchangeEnabled
	}
	return false
}

func (m *GenesisState) GetIsDerivativesExchangeEnabled() bool {
	if m != nil {
		return m.IsDerivativesExchangeEnabled
	}
	return false
}

func (m *GenesisState) GetTradingRewardCampaignInfo() *TradingRewardCampaignInfo {
	if m != nil {
		return m.TradingRewardCampaignInfo
	}
	return nil
}

func (m *GenesisState) GetTradingRewardPoolCampaignSchedule() []*CampaignRewardPool {
	if m != nil {
		return m.TradingRewardPoolCampaignSchedule
	}
	return nil
}

func (m *GenesisState) GetTradingRewardCampaignAccountPoints() []*TradingRewardCampaignAccountPoints {
	if m != nil {
		return m.TradingRewardCampaignAccountPoints
	}
	return nil
}

func (m *GenesisState) GetFeeDiscountSchedule() *FeeDiscountSchedule {
	if m != nil {
		return m.FeeDiscountSchedule
	}
	return nil
}

func (m *GenesisState) GetFeeDiscountAccountTierTtl() []*FeeDiscountAccountTierTTL {
	if m != nil {
		return m.FeeDiscountAccountTierTtl
	}
	return nil
}

func (m *GenesisState) GetFeeDiscountBucketVolumeAccounts() []*FeeDiscountBucketVolumeAccounts {
	if m != nil {
		return m.FeeDiscountBucketVolumeAccounts
	}
	return nil
}

func (m *GenesisState) GetIsFirstFeeCycleFinished() bool {
	if m != nil {
		return m.IsFirstFeeCycleFinished
	}
	return false
}

func (m *GenesisState) GetPendingTradingRewardPoolCampaignSchedule() []*CampaignRewardPool {
	if m != nil {
		return m.PendingTradingRewardPoolCampaignSchedule
	}
	return nil
}

func (m *GenesisState) GetPendingTradingRewardCampaignAccountPoints() []*TradingRewardCampaignAccountPendingPoints {
	if m != nil {
		return m.PendingTradingRewardCampaignAccountPoints
	}
	return nil
}

func (m *GenesisState) GetRewardsOptOutAddresses() []string {
	if m != nil {
		return m.RewardsOptOutAddresses
	}
	return nil
}

func (m *GenesisState) GetHistoricalTradeRecords() []*TradeRecords {
	if m != nil {
		return m.HistoricalTradeRecords
	}
	return nil
}

func (m *GenesisState) GetBinaryOptionsMarkets() []*BinaryOptionsMarket {
	if m != nil {
		return m.BinaryOptionsMarkets
	}
	return nil
}

func (m *GenesisState) GetBinaryOptionsMarketIdsScheduledForSettlement() []string {
	if m != nil {
		return m.BinaryOptionsMarketIdsScheduledForSettlement
	}
	return nil
}

func (m *GenesisState) GetSpotMarketIdsScheduledToForceClose() []string {
	if m != nil {
		return m.SpotMarketIdsScheduledToForceClose
	}
	return nil
}

func (m *GenesisState) GetDenomDecimals() []DenomDecimals {
	if m != nil {
		return m.DenomDecimals
	}
	return nil
}

func (m *GenesisState) GetConditionalDerivativeOrderbooks() []*ConditionalDerivativeOrderBook {
	if m != nil {
		return m.ConditionalDerivativeOrderbooks
	}
	return nil
}

func (m *GenesisState) GetMarketFeeMultipliers() []*MarketFeeMultiplier {
	if m != nil {
		return m.MarketFeeMultipliers
	}
	return nil
}

func (m *GenesisState) GetOrderbookSequences() []*OrderbookSequence {
	if m != nil {
		return m.OrderbookSequences
	}
	return nil
}

func (m *GenesisState) GetSubaccountVolumes() []*AggregateSubaccountVolumeRecord {
	if m != nil {
		return m.SubaccountVolumes
	}
	return nil
}

func (m *GenesisState) GetMarketVolumes() []*MarketVolume {
	if m != nil {
		return m.MarketVolumes
	}
	return nil
}

type OrderbookSequence struct {
	Sequence uint64 `protobuf:"varint,1,opt,name=sequence,proto3" json:"sequence,omitempty"`
	MarketId string `protobuf:"bytes,2,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
}

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

var xxx_messageInfo_OrderbookSequence proto.InternalMessageInfo

func (m *OrderbookSequence) GetSequence() uint64 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

func (m *OrderbookSequence) GetMarketId() string {
	if m != nil {
		return m.MarketId
	}
	return ""
}

type FeeDiscountAccountTierTTL struct {
	Account string              `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	TierTtl *FeeDiscountTierTTL `protobuf:"bytes,2,opt,name=tier_ttl,json=tierTtl,proto3" json:"tier_ttl,omitempty"`
}

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

var xxx_messageInfo_FeeDiscountAccountTierTTL proto.InternalMessageInfo

func (m *FeeDiscountAccountTierTTL) GetAccount() string {
	if m != nil {
		return m.Account
	}
	return ""
}

func (m *FeeDiscountAccountTierTTL) GetTierTtl() *FeeDiscountTierTTL {
	if m != nil {
		return m.TierTtl
	}
	return nil
}

type FeeDiscountBucketVolumeAccounts struct {
	BucketStartTimestamp int64            `protobuf:"varint,1,opt,name=bucket_start_timestamp,json=bucketStartTimestamp,proto3" json:"bucket_start_timestamp,omitempty"`
	AccountVolume        []*AccountVolume `protobuf:"bytes,2,rep,name=account_volume,json=accountVolume,proto3" json:"account_volume,omitempty"`
}

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

var xxx_messageInfo_FeeDiscountBucketVolumeAccounts proto.InternalMessageInfo

func (m *FeeDiscountBucketVolumeAccounts) GetBucketStartTimestamp() int64 {
	if m != nil {
		return m.BucketStartTimestamp
	}
	return 0
}

func (m *FeeDiscountBucketVolumeAccounts) GetAccountVolume() []*AccountVolume {
	if m != nil {
		return m.AccountVolume
	}
	return nil
}

type AccountVolume struct {
	Account string                                 `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	Volume  github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=volume,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"volume"`
}

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

var xxx_messageInfo_AccountVolume proto.InternalMessageInfo

func (m *AccountVolume) GetAccount() string {
	if m != nil {
		return m.Account
	}
	return ""
}

type TradingRewardCampaignAccountPoints struct {
	Account string                                 `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	Points  github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=points,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"points"`
}

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

var xxx_messageInfo_TradingRewardCampaignAccountPoints proto.InternalMessageInfo

func (m *TradingRewardCampaignAccountPoints) GetAccount() string {
	if m != nil {
		return m.Account
	}
	return ""
}

type TradingRewardCampaignAccountPendingPoints struct {
	RewardPoolStartTimestamp int64                                 `protobuf:"varint,1,opt,name=reward_pool_start_timestamp,json=rewardPoolStartTimestamp,proto3" json:"reward_pool_start_timestamp,omitempty"`
	AccountPoints            []*TradingRewardCampaignAccountPoints `protobuf:"bytes,2,rep,name=account_points,json=accountPoints,proto3" json:"account_points,omitempty"`
}

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

var xxx_messageInfo_TradingRewardCampaignAccountPendingPoints proto.InternalMessageInfo

func (m *TradingRewardCampaignAccountPendingPoints) GetRewardPoolStartTimestamp() int64 {
	if m != nil {
		return m.RewardPoolStartTimestamp
	}
	return 0
}

func (m *TradingRewardCampaignAccountPendingPoints) GetAccountPoints() []*TradingRewardCampaignAccountPoints {
	if m != nil {
		return m.AccountPoints
	}
	return nil
}

// Spot Exchange Limit Orderbook
type SpotOrderBook struct {
	MarketId  string            `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	IsBuySide bool              `protobuf:"varint,2,opt,name=isBuySide,proto3" json:"isBuySide,omitempty"`
	Orders    []*SpotLimitOrder `protobuf:"bytes,3,rep,name=orders,proto3" json:"orders,omitempty"`
}

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

var xxx_messageInfo_SpotOrderBook proto.InternalMessageInfo

// Derivative Exchange Limit Orderbook
type DerivativeOrderBook struct {
	MarketId  string                  `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	IsBuySide bool                    `protobuf:"varint,2,opt,name=isBuySide,proto3" json:"isBuySide,omitempty"`
	Orders    []*DerivativeLimitOrder `protobuf:"bytes,3,rep,name=orders,proto3" json:"orders,omitempty"`
}

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

var xxx_messageInfo_DerivativeOrderBook proto.InternalMessageInfo

// Orderbook containing limit & market conditional orders
type ConditionalDerivativeOrderBook struct {
	MarketId         string                   `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	LimitBuyOrders   []*DerivativeLimitOrder  `protobuf:"bytes,2,rep,name=limit_buy_orders,json=limitBuyOrders,proto3" json:"limit_buy_orders,omitempty"`
	MarketBuyOrders  []*DerivativeMarketOrder `protobuf:"bytes,3,rep,name=market_buy_orders,json=marketBuyOrders,proto3" json:"market_buy_orders,omitempty"`
	LimitSellOrders  []*DerivativeLimitOrder  `protobuf:"bytes,4,rep,name=limit_sell_orders,json=limitSellOrders,proto3" json:"limit_sell_orders,omitempty"`
	MarketSellOrders []*DerivativeMarketOrder `protobuf:"bytes,5,rep,name=market_sell_orders,json=marketSellOrders,proto3" json:"market_sell_orders,omitempty"`
}

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

var xxx_messageInfo_ConditionalDerivativeOrderBook proto.InternalMessageInfo

type Balance struct {
	SubaccountId string   `protobuf:"bytes,1,opt,name=subaccount_id,json=subaccountId,proto3" json:"subaccount_id,omitempty"`
	Denom        string   `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"`
	Deposits     *Deposit `protobuf:"bytes,3,opt,name=deposits,proto3" json:"deposits,omitempty"`
}

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

var xxx_messageInfo_Balance proto.InternalMessageInfo

type DerivativePosition struct {
	SubaccountId string    `protobuf:"bytes,1,opt,name=subaccount_id,json=subaccountId,proto3" json:"subaccount_id,omitempty"`
	MarketId     string    `protobuf:"bytes,2,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	Position     *Position `protobuf:"bytes,3,opt,name=position,proto3" json:"position,omitempty"`
}

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

var xxx_messageInfo_DerivativePosition proto.InternalMessageInfo

type SubaccountNonce struct {
	SubaccountId         string               `protobuf:"bytes,1,opt,name=subaccount_id,json=subaccountId,proto3" json:"subaccount_id,omitempty"`
	SubaccountTradeNonce SubaccountTradeNonce `protobuf:"bytes,2,opt,name=subaccount_trade_nonce,json=subaccountTradeNonce,proto3" json:"subaccount_trade_nonce"`
}

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

var xxx_messageInfo_SubaccountNonce proto.InternalMessageInfo

type ExpiryFuturesMarketInfoState struct {
	MarketId   string                   `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	MarketInfo *ExpiryFuturesMarketInfo `protobuf:"bytes,2,opt,name=market_info,json=marketInfo,proto3" json:"market_info,omitempty"`
}

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

var xxx_messageInfo_ExpiryFuturesMarketInfoState proto.InternalMessageInfo

func (m *ExpiryFuturesMarketInfoState) GetMarketId() string {
	if m != nil {
		return m.MarketId
	}
	return ""
}

func (m *ExpiryFuturesMarketInfoState) GetMarketInfo() *ExpiryFuturesMarketInfo {
	if m != nil {
		return m.MarketInfo
	}
	return nil
}

type PerpetualMarketFundingState struct {
	MarketId string                  `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	Funding  *PerpetualMarketFunding `protobuf:"bytes,2,opt,name=funding,proto3" json:"funding,omitempty"`
}

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

var xxx_messageInfo_PerpetualMarketFundingState proto.InternalMessageInfo

func (m *PerpetualMarketFundingState) GetMarketId() string {
	if m != nil {
		return m.MarketId
	}
	return ""
}

func (m *PerpetualMarketFundingState) GetFunding() *PerpetualMarketFunding {
	if m != nil {
		return m.Funding
	}
	return nil
}

func init() {
	proto.RegisterType((*GenesisState)(nil), "injective.exchange.v1beta1.GenesisState")
	proto.RegisterType((*OrderbookSequence)(nil), "injective.exchange.v1beta1.OrderbookSequence")
	proto.RegisterType((*FeeDiscountAccountTierTTL)(nil), "injective.exchange.v1beta1.FeeDiscountAccountTierTTL")
	proto.RegisterType((*FeeDiscountBucketVolumeAccounts)(nil), "injective.exchange.v1beta1.FeeDiscountBucketVolumeAccounts")
	proto.RegisterType((*AccountVolume)(nil), "injective.exchange.v1beta1.AccountVolume")
	proto.RegisterType((*TradingRewardCampaignAccountPoints)(nil), "injective.exchange.v1beta1.TradingRewardCampaignAccountPoints")
	proto.RegisterType((*TradingRewardCampaignAccountPendingPoints)(nil), "injective.exchange.v1beta1.TradingRewardCampaignAccountPendingPoints")
	proto.RegisterType((*SpotOrderBook)(nil), "injective.exchange.v1beta1.SpotOrderBook")
	proto.RegisterType((*DerivativeOrderBook)(nil), "injective.exchange.v1beta1.DerivativeOrderBook")
	proto.RegisterType((*ConditionalDerivativeOrderBook)(nil), "injective.exchange.v1beta1.ConditionalDerivativeOrderBook")
	proto.RegisterType((*Balance)(nil), "injective.exchange.v1beta1.Balance")
	proto.RegisterType((*DerivativePosition)(nil), "injective.exchange.v1beta1.DerivativePosition")
	proto.RegisterType((*SubaccountNonce)(nil), "injective.exchange.v1beta1.SubaccountNonce")
	proto.RegisterType((*ExpiryFuturesMarketInfoState)(nil), "injective.exchange.v1beta1.ExpiryFuturesMarketInfoState")
	proto.RegisterType((*PerpetualMarketFundingState)(nil), "injective.exchange.v1beta1.PerpetualMarketFundingState")
}

func init() {
	proto.RegisterFile("injective/exchange/v1beta1/genesis.proto", fileDescriptor_c47ec6b98758ed05)
}

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

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

func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MarketVolumes) > 0 {
		for iNdEx := len(m.MarketVolumes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MarketVolumes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.SubaccountVolumes) > 0 {
		for iNdEx := len(m.SubaccountVolumes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SubaccountVolumes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.OrderbookSequences) > 0 {
		for iNdEx := len(m.OrderbookSequences) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OrderbookSequences[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.MarketFeeMultipliers) > 0 {
		for iNdEx := len(m.MarketFeeMultipliers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MarketFeeMultipliers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xfa
		}
	}
	if len(m.ConditionalDerivativeOrderbooks) > 0 {
		for iNdEx := len(m.ConditionalDerivativeOrderbooks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ConditionalDerivativeOrderbooks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xf2
		}
	}
	if len(m.DenomDecimals) > 0 {
		for iNdEx := len(m.DenomDecimals) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DenomDecimals[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xea
		}
	}
	if len(m.SpotMarketIdsScheduledToForceClose) > 0 {
		for iNdEx := len(m.SpotMarketIdsScheduledToForceClose) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SpotMarketIdsScheduledToForceClose[iNdEx])
			copy(dAtA[i:], m.SpotMarketIdsScheduledToForceClose[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.SpotMarketIdsScheduledToForceClose[iNdEx])))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xe2
		}
	}
	if len(m.BinaryOptionsMarketIdsScheduledForSettlement) > 0 {
		for iNdEx := len(m.BinaryOptionsMarketIdsScheduledForSettlement) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BinaryOptionsMarketIdsScheduledForSettlement[iNdEx])
			copy(dAtA[i:], m.BinaryOptionsMarketIdsScheduledForSettlement[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.BinaryOptionsMarketIdsScheduledForSettlement[iNdEx])))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xda
		}
	}
	if len(m.BinaryOptionsMarkets) > 0 {
		for iNdEx := len(m.BinaryOptionsMarkets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BinaryOptionsMarkets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xd2
		}
	}
	if len(m.HistoricalTradeRecords) > 0 {
		for iNdEx := len(m.HistoricalTradeRecords) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.HistoricalTradeRecords[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xca
		}
	}
	if len(m.RewardsOptOutAddresses) > 0 {
		for iNdEx := len(m.RewardsOptOutAddresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RewardsOptOutAddresses[iNdEx])
			copy(dAtA[i:], m.RewardsOptOutAddresses[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.RewardsOptOutAddresses[iNdEx])))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xc2
		}
	}
	if len(m.PendingTradingRewardCampaignAccountPoints) > 0 {
		for iNdEx := len(m.PendingTradingRewardCampaignAccountPoints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PendingTradingRewardCampaignAccountPoints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xba
		}
	}
	if len(m.PendingTradingRewardPoolCampaignSchedule) > 0 {
		for iNdEx := len(m.PendingTradingRewardPoolCampaignSchedule) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PendingTradingRewardPoolCampaignSchedule[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xb2
		}
	}
	if m.IsFirstFeeCycleFinished {
		i--
		if m.IsFirstFeeCycleFinished {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa8
	}
	if len(m.FeeDiscountBucketVolumeAccounts) > 0 {
		for iNdEx := len(m.FeeDiscountBucketVolumeAccounts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FeeDiscountBucketVolumeAccounts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.FeeDiscountAccountTierTtl) > 0 {
		for iNdEx := len(m.FeeDiscountAccountTierTtl) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FeeDiscountAccountTierTtl[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	if m.FeeDiscountSchedule != nil {
		{
			size, err := m.FeeDiscountSchedule.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	if len(m.TradingRewardCampaignAccountPoints) > 0 {
		for iNdEx := len(m.TradingRewardCampaignAccountPoints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TradingRewardCampaignAccountPoints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.TradingRewardPoolCampaignSchedule) > 0 {
		for iNdEx := len(m.TradingRewardPoolCampaignSchedule) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TradingRewardPoolCampaignSchedule[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x82
		}
	}
	if m.TradingRewardCampaignInfo != nil {
		{
			size, err := m.TradingRewardCampaignInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	if m.IsDerivativesExchangeEnabled {
		i--
		if m.IsDerivativesExchangeEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x70
	}
	if m.IsSpotExchangeEnabled {
		i--
		if m.IsSpotExchangeEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	if len(m.DerivativeMarketSettlementScheduled) > 0 {
		for iNdEx := len(m.DerivativeMarketSettlementScheduled) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DerivativeMarketSettlementScheduled[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.PerpetualMarketFundingState) > 0 {
		for iNdEx := len(m.PerpetualMarketFundingState) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PerpetualMarketFundingState[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.PerpetualMarketInfo) > 0 {
		for iNdEx := len(m.PerpetualMarketInfo) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PerpetualMarketInfo[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.ExpiryFuturesMarketInfoState) > 0 {
		for iNdEx := len(m.ExpiryFuturesMarketInfoState) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ExpiryFuturesMarketInfoState[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.SubaccountTradeNonces) > 0 {
		for iNdEx := len(m.SubaccountTradeNonces) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SubaccountTradeNonces[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.Positions) > 0 {
		for iNdEx := len(m.Positions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Positions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.Balances) > 0 {
		for iNdEx := len(m.Balances) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Balances[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.DerivativeOrderbook) > 0 {
		for iNdEx := len(m.DerivativeOrderbook) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DerivativeOrderbook[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.SpotOrderbook) > 0 {
		for iNdEx := len(m.SpotOrderbook) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SpotOrderbook[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.DerivativeMarkets) > 0 {
		for iNdEx := len(m.DerivativeMarkets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DerivativeMarkets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.SpotMarkets) > 0 {
		for iNdEx := len(m.SpotMarkets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SpotMarkets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *OrderbookSequence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MarketId) > 0 {
		i -= len(m.MarketId)
		copy(dAtA[i:], m.MarketId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.MarketId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Sequence != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *FeeDiscountBucketVolumeAccounts) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AccountVolume) > 0 {
		for iNdEx := len(m.AccountVolume) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AccountVolume[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.BucketStartTimestamp != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.BucketStartTimestamp))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *AccountVolume) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Volume.Size()
		i -= size
		if _, err := m.Volume.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Account) > 0 {
		i -= len(m.Account)
		copy(dAtA[i:], m.Account)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Account)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TradingRewardCampaignAccountPoints) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Points.Size()
		i -= size
		if _, err := m.Points.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Account) > 0 {
		i -= len(m.Account)
		copy(dAtA[i:], m.Account)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Account)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TradingRewardCampaignAccountPendingPoints) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AccountPoints) > 0 {
		for iNdEx := len(m.AccountPoints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AccountPoints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.RewardPoolStartTimestamp != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.RewardPoolStartTimestamp))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SpotOrderBook) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Orders) > 0 {
		for iNdEx := len(m.Orders) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Orders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.IsBuySide {
		i--
		if m.IsBuySide {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.MarketId) > 0 {
		i -= len(m.MarketId)
		copy(dAtA[i:], m.MarketId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.MarketId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *DerivativeOrderBook) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Orders) > 0 {
		for iNdEx := len(m.Orders) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Orders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.IsBuySide {
		i--
		if m.IsBuySide {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.MarketId) > 0 {
		i -= len(m.MarketId)
		copy(dAtA[i:], m.MarketId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.MarketId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ConditionalDerivativeOrderBook) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MarketSellOrders) > 0 {
		for iNdEx := len(m.MarketSellOrders) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MarketSellOrders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.LimitSellOrders) > 0 {
		for iNdEx := len(m.LimitSellOrders) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LimitSellOrders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.MarketBuyOrders) > 0 {
		for iNdEx := len(m.MarketBuyOrders) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MarketBuyOrders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.LimitBuyOrders) > 0 {
		for iNdEx := len(m.LimitBuyOrders) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LimitBuyOrders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.MarketId) > 0 {
		i -= len(m.MarketId)
		copy(dAtA[i:], m.MarketId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.MarketId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Balance) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Deposits != nil {
		{
			size, err := m.Deposits.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Denom)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SubaccountId) > 0 {
		i -= len(m.SubaccountId)
		copy(dAtA[i:], m.SubaccountId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.SubaccountId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *DerivativePosition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Position != nil {
		{
			size, err := m.Position.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.MarketId) > 0 {
		i -= len(m.MarketId)
		copy(dAtA[i:], m.MarketId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.MarketId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SubaccountId) > 0 {
		i -= len(m.SubaccountId)
		copy(dAtA[i:], m.SubaccountId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.SubaccountId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
	offset -= sovGenesis(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *GenesisState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Params.Size()
	n += 1 + l + sovGenesis(uint64(l))
	if len(m.SpotMarkets) > 0 {
		for _, e := range m.SpotMarkets {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.DerivativeMarkets) > 0 {
		for _, e := range m.DerivativeMarkets {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.SpotOrderbook) > 0 {
		for _, e := range m.SpotOrderbook {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.DerivativeOrderbook) > 0 {
		for _, e := range m.DerivativeOrderbook {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.Balances) > 0 {
		for _, e := range m.Balances {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.Positions) > 0 {
		for _, e := range m.Positions {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.SubaccountTradeNonces) > 0 {
		for _, e := range m.SubaccountTradeNonces {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ExpiryFuturesMarketInfoState) > 0 {
		for _, e := range m.ExpiryFuturesMarketInfoState {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.PerpetualMarketInfo) > 0 {
		for _, e := range m.PerpetualMarketInfo {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.PerpetualMarketFundingState) > 0 {
		for _, e := range m.PerpetualMarketFundingState {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.DerivativeMarketSettlementScheduled) > 0 {
		for _, e := range m.DerivativeMarketSettlementScheduled {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if m.IsSpotExchangeEnabled {
		n += 2
	}
	if m.IsDerivativesExchangeEnabled {
		n += 2
	}
	if m.TradingRewardCampaignInfo != nil {
		l = m.TradingRewardCampaignInfo.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	if len(m.TradingRewardPoolCampaignSchedule) > 0 {
		for _, e := range m.TradingRewardPoolCampaignSchedule {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.TradingRewardCampaignAccountPoints) > 0 {
		for _, e := range m.TradingRewardCampaignAccountPoints {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if m.FeeDiscountSchedule != nil {
		l = m.FeeDiscountSchedule.Size()
		n += 2 + l + sovGenesis(uint64(l))
	}
	if len(m.FeeDiscountAccountTierTtl) > 0 {
		for _, e := range m.FeeDiscountAccountTierTtl {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.FeeDiscountBucketVolumeAccounts) > 0 {
		for _, e := range m.FeeDiscountBucketVolumeAccounts {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if m.IsFirstFeeCycleFinished {
		n += 3
	}
	if len(m.PendingTradingRewardPoolCampaignSchedule) > 0 {
		for _, e := range m.PendingTradingRewardPoolCampaignSchedule {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.PendingTradingRewardCampaignAccountPoints) > 0 {
		for _, e := range m.PendingTradingRewardCampaignAccountPoints {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.RewardsOptOutAddresses) > 0 {
		for _, s := range m.RewardsOptOutAddresses {
			l = len(s)
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.HistoricalTradeRecords) > 0 {
		for _, e := range m.HistoricalTradeRecords {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.BinaryOptionsMarkets) > 0 {
		for _, e := range m.BinaryOptionsMarkets {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.BinaryOptionsMarketIdsScheduledForSettlement) > 0 {
		for _, s := range m.BinaryOptionsMarketIdsScheduledForSettlement {
			l = len(s)
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.SpotMarketIdsScheduledToForceClose) > 0 {
		for _, s := range m.SpotMarketIdsScheduledToForceClose {
			l = len(s)
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.DenomDecimals) > 0 {
		for _, e := range m.DenomDecimals {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ConditionalDerivativeOrderbooks) > 0 {
		for _, e := range m.ConditionalDerivativeOrderbooks {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.MarketFeeMultipliers) > 0 {
		for _, e := range m.MarketFeeMultipliers {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.OrderbookSequences) > 0 {
		for _, e := range m.OrderbookSequences {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.SubaccountVolumes) > 0 {
		for _, e := range m.SubaccountVolumes {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.MarketVolumes) > 0 {
		for _, e := range m.MarketVolumes {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	return n
}

func (m *OrderbookSequence) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Sequence != 0 {
		n += 1 + sovGenesis(uint64(m.Sequence))
	}
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *FeeDiscountAccountTierTTL) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Account)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.TierTtl != nil {
		l = m.TierTtl.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *FeeDiscountBucketVolumeAccounts) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BucketStartTimestamp != 0 {
		n += 1 + sovGenesis(uint64(m.BucketStartTimestamp))
	}
	if len(m.AccountVolume) > 0 {
		for _, e := range m.AccountVolume {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	return n
}

func (m *AccountVolume) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Account)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.Volume.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *TradingRewardCampaignAccountPoints) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Account)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.Points.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *TradingRewardCampaignAccountPendingPoints) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RewardPoolStartTimestamp != 0 {
		n += 1 + sovGenesis(uint64(m.RewardPoolStartTimestamp))
	}
	if len(m.AccountPoints) > 0 {
		for _, e := range m.AccountPoints {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	return n
}

func (m *SpotOrderBook) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.IsBuySide {
		n += 2
	}
	if len(m.Orders) > 0 {
		for _, e := range m.Orders {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	return n
}

func (m *DerivativeOrderBook) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.IsBuySide {
		n += 2
	}
	if len(m.Orders) > 0 {
		for _, e := range m.Orders {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	return n
}

func (m *ConditionalDerivativeOrderBook) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if len(m.LimitBuyOrders) > 0 {
		for _, e := range m.LimitBuyOrders {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.MarketBuyOrders) > 0 {
		for _, e := range m.MarketBuyOrders {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LimitSellOrders) > 0 {
		for _, e := range m.LimitSellOrders {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.MarketSellOrders) > 0 {
		for _, e := range m.MarketSellOrders {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	return n
}

func (m *Balance) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SubaccountId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.Denom)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.Deposits != nil {
		l = m.Deposits.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *DerivativePosition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SubaccountId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.Position != nil {
		l = m.Position.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *SubaccountNonce) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SubaccountId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.SubaccountTradeNonce.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *ExpiryFuturesMarketInfoState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.MarketInfo != nil {
		l = m.MarketInfo.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *PerpetualMarketFundingState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.Funding != nil {
		l = m.Funding.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func sovGenesis(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozGenesis(x uint64) (n int) {
	return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GenesisState) 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 ErrIntOverflowGenesis
			}
			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: GenesisState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpotMarkets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpotMarkets = append(m.SpotMarkets, &SpotMarket{})
			if err := m.SpotMarkets[len(m.SpotMarkets)-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 DerivativeMarkets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DerivativeMarkets = append(m.DerivativeMarkets, &DerivativeMarket{})
			if err := m.DerivativeMarkets[len(m.DerivativeMarkets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpotOrderbook", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpotOrderbook = append(m.SpotOrderbook, SpotOrderBook{})
			if err := m.SpotOrderbook[len(m.SpotOrderbook)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DerivativeOrderbook", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DerivativeOrderbook = append(m.DerivativeOrderbook, DerivativeOrderBook{})
			if err := m.DerivativeOrderbook[len(m.DerivativeOrderbook)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Balances", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Balances = append(m.Balances, Balance{})
			if err := m.Balances[len(m.Balances)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Positions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Positions = append(m.Positions, DerivativePosition{})
			if err := m.Positions[len(m.Positions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubaccountTradeNonces", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubaccountTradeNonces = append(m.SubaccountTradeNonces, SubaccountNonce{})
			if err := m.SubaccountTradeNonces[len(m.SubaccountTradeNonces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpiryFuturesMarketInfoState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExpiryFuturesMarketInfoState = append(m.ExpiryFuturesMarketInfoState, ExpiryFuturesMarketInfoState{})
			if err := m.ExpiryFuturesMarketInfoState[len(m.ExpiryFuturesMarketInfoState)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PerpetualMarketInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PerpetualMarketInfo = append(m.PerpetualMarketInfo, PerpetualMarketInfo{})
			if err := m.PerpetualMarketInfo[len(m.PerpetualMarketInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PerpetualMarketFundingState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PerpetualMarketFundingState = append(m.PerpetualMarketFundingState, PerpetualMarketFundingState{})
			if err := m.PerpetualMarketFundingState[len(m.PerpetualMarketFundingState)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DerivativeMarketSettlementScheduled", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DerivativeMarketSettlementScheduled = append(m.DerivativeMarketSettlementScheduled, DerivativeMarketSettlementInfo{})
			if err := m.DerivativeMarketSettlementScheduled[len(m.DerivativeMarketSettlementScheduled)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsSpotExchangeEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsSpotExchangeEnabled = bool(v != 0)
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsDerivativesExchangeEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsDerivativesExchangeEnabled = bool(v != 0)
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TradingRewardCampaignInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TradingRewardCampaignInfo == nil {
				m.TradingRewardCampaignInfo = &TradingRewardCampaignInfo{}
			}
			if err := m.TradingRewardCampaignInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TradingRewardPoolCampaignSchedule", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TradingRewardPoolCampaignSchedule = append(m.TradingRewardPoolCampaignSchedule, &CampaignRewardPool{})
			if err := m.TradingRewardPoolCampaignSchedule[len(m.TradingRewardPoolCampaignSchedule)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TradingRewardCampaignAccountPoints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TradingRewardCampaignAccountPoints = append(m.TradingRewardCampaignAccountPoints, &TradingRewardCampaignAccountPoints{})
			if err := m.TradingRewardCampaignAccountPoints[len(m.TradingRewardCampaignAccountPoints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeeDiscountSchedule", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FeeDiscountSchedule == nil {
				m.FeeDiscountSchedule = &FeeDiscountSchedule{}
			}
			if err := m.FeeDiscountSchedule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeeDiscountAccountTierTtl", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FeeDiscountAccountTierTtl = append(m.FeeDiscountAccountTierTtl, &FeeDiscountAccountTierTTL{})
			if err := m.FeeDiscountAccountTierTtl[len(m.FeeDiscountAccountTierTtl)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeeDiscountBucketVolumeAccounts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FeeDiscountBucketVolumeAccounts = append(m.FeeDiscountBucketVolumeAccounts, &FeeDiscountBucketVolumeAccounts{})
			if err := m.FeeDiscountBucketVolumeAccounts[len(m.FeeDiscountBucketVolumeAccounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsFirstFeeCycleFinished", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsFirstFeeCycleFinished = bool(v != 0)
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PendingTradingRewardPoolCampaignSchedule", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PendingTradingRewardPoolCampaignSchedule = append(m.PendingTradingRewardPoolCampaignSchedule, &CampaignRewardPool{})
			if err := m.PendingTradingRewardPoolCampaignSchedule[len(m.PendingTradingRewardPoolCampaignSchedule)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PendingTradingRewardCampaignAccountPoints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PendingTradingRewardCampaignAccountPoints = append(m.PendingTradingRewardCampaignAccountPoints, &TradingRewardCampaignAccountPendingPoints{})
			if err := m.PendingTradingRewardCampaignAccountPoints[len(m.PendingTradingRewardCampaignAccountPoints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RewardsOptOutAddresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RewardsOptOutAddresses = append(m.RewardsOptOutAddresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HistoricalTradeRecords", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HistoricalTradeRecords = append(m.HistoricalTradeRecords, &TradeRecords{})
			if err := m.HistoricalTradeRecords[len(m.HistoricalTradeRecords)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BinaryOptionsMarkets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BinaryOptionsMarkets = append(m.BinaryOptionsMarkets, &BinaryOptionsMarket{})
			if err := m.BinaryOptionsMarkets[len(m.BinaryOptionsMarkets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 27:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BinaryOptionsMarketIdsScheduledForSettlement", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BinaryOptionsMarketIdsScheduledForSettlement = append(m.BinaryOptionsMarketIdsScheduledForSettlement, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpotMarketIdsScheduledToForceClose", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpotMarketIdsScheduledToForceClose = append(m.SpotMarketIdsScheduledToForceClose, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 29:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DenomDecimals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DenomDecimals = append(m.DenomDecimals, DenomDecimals{})
			if err := m.DenomDecimals[len(m.DenomDecimals)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConditionalDerivativeOrderbooks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConditionalDerivativeOrderbooks = append(m.ConditionalDerivativeOrderbooks, &ConditionalDerivativeOrderBook{})
			if err := m.ConditionalDerivativeOrderbooks[len(m.ConditionalDerivativeOrderbooks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 31:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MarketFeeMultipliers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MarketFeeMultipliers = append(m.MarketFeeMultipliers, &MarketFeeMultiplier{})
			if err := m.MarketFeeMultipliers[len(m.MarketFeeMultipliers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 32:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderbookSequences", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderbookSequences = append(m.OrderbookSequences, &OrderbookSequence{})
			if err := m.OrderbookSequences[len(m.OrderbookSequences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 33:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubaccountVolumes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubaccountVolumes = append(m.SubaccountVolumes, &AggregateSubaccountVolumeRecord{})
			if err := m.SubaccountVolumes[len(m.SubaccountVolumes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 34:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MarketVolumes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MarketVolumes = append(m.MarketVolumes, &MarketVolume{})
			if err := m.MarketVolumes[len(m.MarketVolumes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConditionalDerivativeOrderBook) 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 ErrIntOverflowGenesis
			}
			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: ConditionalDerivativeOrderBook: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConditionalDerivativeOrderBook: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MarketId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MarketId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LimitBuyOrders", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LimitBuyOrders = append(m.LimitBuyOrders, &DerivativeLimitOrder{})
			if err := m.LimitBuyOrders[len(m.LimitBuyOrders)-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 MarketBuyOrders", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MarketBuyOrders = append(m.MarketBuyOrders, &DerivativeMarketOrder{})
			if err := m.MarketBuyOrders[len(m.MarketBuyOrders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LimitSellOrders", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LimitSellOrders = append(m.LimitSellOrders, &DerivativeLimitOrder{})
			if err := m.LimitSellOrders[len(m.LimitSellOrders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MarketSellOrders", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MarketSellOrders = append(m.MarketSellOrders, &DerivativeMarketOrder{})
			if err := m.MarketSellOrders[len(m.MarketSellOrders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

var (
	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
)