github.com/InjectiveLabs/sdk-go@v1.53.0/chain/exchange/types/exchange.pb.go

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

package types

import (
	cosmossdk_io_math "cosmossdk.io/math"
	fmt "fmt"
	types1 "github.com/InjectiveLabs/sdk-go/chain/oracle/types"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/cosmos-sdk/types/tx/amino"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type AtomicMarketOrderAccessLevel int32

const (
	AtomicMarketOrderAccessLevel_Nobody AtomicMarketOrderAccessLevel = 0
	// currently unsupported
	AtomicMarketOrderAccessLevel_BeginBlockerSmartContractsOnly AtomicMarketOrderAccessLevel = 1
	AtomicMarketOrderAccessLevel_SmartContractsOnly             AtomicMarketOrderAccessLevel = 2
	AtomicMarketOrderAccessLevel_Everyone                       AtomicMarketOrderAccessLevel = 3
)

var AtomicMarketOrderAccessLevel_name = map[int32]string{
	0: "Nobody",
	1: "BeginBlockerSmartContractsOnly",
	2: "SmartContractsOnly",
	3: "Everyone",
}

var AtomicMarketOrderAccessLevel_value = map[string]int32{
	"Nobody":                         0,
	"BeginBlockerSmartContractsOnly": 1,
	"SmartContractsOnly":             2,
	"Everyone":                       3,
}

func (x AtomicMarketOrderAccessLevel) String() string {
	return proto.EnumName(AtomicMarketOrderAccessLevel_name, int32(x))
}

func (AtomicMarketOrderAccessLevel) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2116e2804e9c53f9, []int{0}
}

type MarketStatus int32

const (
	MarketStatus_Unspecified MarketStatus = 0
	MarketStatus_Active      MarketStatus = 1
	MarketStatus_Paused      MarketStatus = 2
	MarketStatus_Demolished  MarketStatus = 3
	MarketStatus_Expired     MarketStatus = 4
)

var MarketStatus_name = map[int32]string{
	0: "Unspecified",
	1: "Active",
	2: "Paused",
	3: "Demolished",
	4: "Expired",
}

var MarketStatus_value = map[string]int32{
	"Unspecified": 0,
	"Active":      1,
	"Paused":      2,
	"Demolished":  3,
	"Expired":     4,
}

func (x MarketStatus) String() string {
	return proto.EnumName(MarketStatus_name, int32(x))
}

func (MarketStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2116e2804e9c53f9, []int{1}
}

type OrderType int32

const (
	OrderType_UNSPECIFIED OrderType = 0
	OrderType_BUY         OrderType = 1
	OrderType_SELL        OrderType = 2
	OrderType_STOP_BUY    OrderType = 3
	OrderType_STOP_SELL   OrderType = 4
	OrderType_TAKE_BUY    OrderType = 5
	OrderType_TAKE_SELL   OrderType = 6
	OrderType_BUY_PO      OrderType = 7
	OrderType_SELL_PO     OrderType = 8
	OrderType_BUY_ATOMIC  OrderType = 9
	OrderType_SELL_ATOMIC OrderType = 10
)

var OrderType_name = map[int32]string{
	0:  "UNSPECIFIED",
	1:  "BUY",
	2:  "SELL",
	3:  "STOP_BUY",
	4:  "STOP_SELL",
	5:  "TAKE_BUY",
	6:  "TAKE_SELL",
	7:  "BUY_PO",
	8:  "SELL_PO",
	9:  "BUY_ATOMIC",
	10: "SELL_ATOMIC",
}

var OrderType_value = map[string]int32{
	"UNSPECIFIED": 0,
	"BUY":         1,
	"SELL":        2,
	"STOP_BUY":    3,
	"STOP_SELL":   4,
	"TAKE_BUY":    5,
	"TAKE_SELL":   6,
	"BUY_PO":      7,
	"SELL_PO":     8,
	"BUY_ATOMIC":  9,
	"SELL_ATOMIC": 10,
}

func (x OrderType) String() string {
	return proto.EnumName(OrderType_name, int32(x))
}

func (OrderType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2116e2804e9c53f9, []int{2}
}

type ExecutionType int32

const (
	ExecutionType_UnspecifiedExecutionType ExecutionType = 0
	ExecutionType_Market                   ExecutionType = 1
	ExecutionType_LimitFill                ExecutionType = 2
	ExecutionType_LimitMatchRestingOrder   ExecutionType = 3
	ExecutionType_LimitMatchNewOrder       ExecutionType = 4
	ExecutionType_MarketLiquidation        ExecutionType = 5
	ExecutionType_ExpiryMarketSettlement   ExecutionType = 6
)

var ExecutionType_name = map[int32]string{
	0: "UnspecifiedExecutionType",
	1: "Market",
	2: "LimitFill",
	3: "LimitMatchRestingOrder",
	4: "LimitMatchNewOrder",
	5: "MarketLiquidation",
	6: "ExpiryMarketSettlement",
}

var ExecutionType_value = map[string]int32{
	"UnspecifiedExecutionType": 0,
	"Market":                   1,
	"LimitFill":                2,
	"LimitMatchRestingOrder":   3,
	"LimitMatchNewOrder":       4,
	"MarketLiquidation":        5,
	"ExpiryMarketSettlement":   6,
}

func (x ExecutionType) String() string {
	return proto.EnumName(ExecutionType_name, int32(x))
}

func (ExecutionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2116e2804e9c53f9, []int{3}
}

type OrderMask int32

const (
	OrderMask_UNUSED        OrderMask = 0
	OrderMask_ANY           OrderMask = 1
	OrderMask_REGULAR       OrderMask = 2
	OrderMask_CONDITIONAL   OrderMask = 4
	OrderMask_BUY_OR_HIGHER OrderMask = 8
	OrderMask_SELL_OR_LOWER OrderMask = 16
	OrderMask_MARKET        OrderMask = 32
	OrderMask_LIMIT         OrderMask = 64
)

var OrderMask_name = map[int32]string{
	0:  "UNUSED",
	1:  "ANY",
	2:  "REGULAR",
	4:  "CONDITIONAL",
	8:  "DIRECTION_BUY_OR_HIGHER",
	16: "DIRECTION_SELL_OR_LOWER",
	32: "TYPE_MARKET",
	64: "TYPE_LIMIT",
}

var OrderMask_value = map[string]int32{
	"UNUSED":                  0,
	"ANY":                     1,
	"REGULAR":                 2,
	"CONDITIONAL":             4,
	"DIRECTION_BUY_OR_HIGHER": 8,
	"DIRECTION_SELL_OR_LOWER": 16,
	"TYPE_MARKET":             32,
	"TYPE_LIMIT":              64,
}

func (x OrderMask) String() string {
	return proto.EnumName(OrderMask_name, int32(x))
}

func (OrderMask) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2116e2804e9c53f9, []int{4}
}

type Params struct {
	// spot_market_instant_listing_fee defines the expedited fee in INJ required
	// to create a spot market by bypassing governance
	SpotMarketInstantListingFee types.Coin `protobuf:"bytes,1,opt,name=spot_market_instant_listing_fee,json=spotMarketInstantListingFee,proto3" json:"spot_market_instant_listing_fee"`
	// derivative_market_instant_listing_fee defines the expedited fee in INJ
	// required to create a derivative market by bypassing governance
	DerivativeMarketInstantListingFee types.Coin `protobuf:"bytes,2,opt,name=derivative_market_instant_listing_fee,json=derivativeMarketInstantListingFee,proto3" json:"derivative_market_instant_listing_fee"`
	// default_spot_maker_fee defines the default exchange trade fee for makers on
	// a spot market
	DefaultSpotMakerFeeRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,3,opt,name=default_spot_maker_fee_rate,json=defaultSpotMakerFeeRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"default_spot_maker_fee_rate"`
	// default_spot_taker_fee_rate defines the default exchange trade fee rate for
	// takers on a new spot market
	DefaultSpotTakerFeeRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=default_spot_taker_fee_rate,json=defaultSpotTakerFeeRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"default_spot_taker_fee_rate"`
	// default_derivative_maker_fee defines the default exchange trade fee for
	// makers on a new derivative market
	DefaultDerivativeMakerFeeRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,5,opt,name=default_derivative_maker_fee_rate,json=defaultDerivativeMakerFeeRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"default_derivative_maker_fee_rate"`
	// default_derivative_taker_fee defines the default exchange trade fee for
	// takers on a new derivative market
	DefaultDerivativeTakerFeeRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,6,opt,name=default_derivative_taker_fee_rate,json=defaultDerivativeTakerFeeRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"default_derivative_taker_fee_rate"`
	// default_initial_margin_ratio defines the default initial margin ratio on a
	// new derivative market
	DefaultInitialMarginRatio cosmossdk_io_math.LegacyDec `protobuf:"bytes,7,opt,name=default_initial_margin_ratio,json=defaultInitialMarginRatio,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"default_initial_margin_ratio"`
	// default_maintenance_margin_ratio defines the default maintenance margin
	// ratio on a new derivative market
	DefaultMaintenanceMarginRatio cosmossdk_io_math.LegacyDec `protobuf:"bytes,8,opt,name=default_maintenance_margin_ratio,json=defaultMaintenanceMarginRatio,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"default_maintenance_margin_ratio"`
	// default_funding_interval defines the default funding interval on a
	// derivative market
	DefaultFundingInterval int64 `protobuf:"varint,9,opt,name=default_funding_interval,json=defaultFundingInterval,proto3" json:"default_funding_interval,omitempty"`
	// funding_multiple defines the timestamp multiple that the funding timestamp
	// should be a multiple of
	FundingMultiple int64 `protobuf:"varint,10,opt,name=funding_multiple,json=fundingMultiple,proto3" json:"funding_multiple,omitempty"`
	// relayer_fee_share_rate defines the trade fee share percentage that goes to
	// relayers
	RelayerFeeShareRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,11,opt,name=relayer_fee_share_rate,json=relayerFeeShareRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"relayer_fee_share_rate"`
	// default_hourly_funding_rate_cap defines the default maximum absolute value
	// of the hourly funding rate
	DefaultHourlyFundingRateCap cosmossdk_io_math.LegacyDec `protobuf:"bytes,12,opt,name=default_hourly_funding_rate_cap,json=defaultHourlyFundingRateCap,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"default_hourly_funding_rate_cap"`
	// hourly_interest_rate defines the hourly interest rate
	DefaultHourlyInterestRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,13,opt,name=default_hourly_interest_rate,json=defaultHourlyInterestRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"default_hourly_interest_rate"`
	// max_derivative_order_side_count defines the maximum number of derivative
	// active orders a subaccount can have for a given orderbook side
	MaxDerivativeOrderSideCount uint32 `protobuf:"varint,14,opt,name=max_derivative_order_side_count,json=maxDerivativeOrderSideCount,proto3" json:"max_derivative_order_side_count,omitempty"`
	// inj_reward_staked_requirement_threshold defines the threshold on INJ
	// rewards after which one also needs staked INJ to receive more
	InjRewardStakedRequirementThreshold cosmossdk_io_math.Int `protobuf:"bytes,15,opt,name=inj_reward_staked_requirement_threshold,json=injRewardStakedRequirementThreshold,proto3,customtype=cosmossdk.io/math.Int" json:"inj_reward_staked_requirement_threshold"`
	// the trading_rewards_vesting_duration defines the vesting times for trading
	// rewards
	TradingRewardsVestingDuration int64 `protobuf:"varint,16,opt,name=trading_rewards_vesting_duration,json=tradingRewardsVestingDuration,proto3" json:"trading_rewards_vesting_duration,omitempty"`
	// liquidator_reward_share_rate defines the ratio of the split of the surplus
	// collateral that goes to the liquidator
	LiquidatorRewardShareRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,17,opt,name=liquidator_reward_share_rate,json=liquidatorRewardShareRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"liquidator_reward_share_rate"`
	// binary_options_market_instant_listing_fee defines the expedited fee in INJ
	// required to create a derivative market by bypassing governance
	BinaryOptionsMarketInstantListingFee types.Coin `protobuf:"bytes,18,opt,name=binary_options_market_instant_listing_fee,json=binaryOptionsMarketInstantListingFee,proto3" json:"binary_options_market_instant_listing_fee"`
	// atomic_market_order_access_level defines the required access permissions
	// for executing atomic market orders
	AtomicMarketOrderAccessLevel AtomicMarketOrderAccessLevel `protobuf:"varint,19,opt,name=atomic_market_order_access_level,json=atomicMarketOrderAccessLevel,proto3,enum=injective.exchange.v1beta1.AtomicMarketOrderAccessLevel" json:"atomic_market_order_access_level,omitempty"`
	// spot_atomic_market_order_fee_multiplier defines the default multiplier for
	// executing atomic market orders in spot markets
	SpotAtomicMarketOrderFeeMultiplier cosmossdk_io_math.LegacyDec `protobuf:"bytes,20,opt,name=spot_atomic_market_order_fee_multiplier,json=spotAtomicMarketOrderFeeMultiplier,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"spot_atomic_market_order_fee_multiplier"`
	// derivative_atomic_market_order_fee_multiplier defines the default
	// multiplier for executing atomic market orders in derivative markets
	DerivativeAtomicMarketOrderFeeMultiplier cosmossdk_io_math.LegacyDec `protobuf:"bytes,21,opt,name=derivative_atomic_market_order_fee_multiplier,json=derivativeAtomicMarketOrderFeeMultiplier,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"derivative_atomic_market_order_fee_multiplier"`
	// binary_options_atomic_market_order_fee_multiplier defines the default
	// multiplier for executing atomic market orders in binary markets
	BinaryOptionsAtomicMarketOrderFeeMultiplier cosmossdk_io_math.LegacyDec `protobuf:"bytes,22,opt,name=binary_options_atomic_market_order_fee_multiplier,json=binaryOptionsAtomicMarketOrderFeeMultiplier,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"binary_options_atomic_market_order_fee_multiplier"`
	// minimal_protocol_fee_rate defines the minimal protocol fee rate
	MinimalProtocolFeeRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,23,opt,name=minimal_protocol_fee_rate,json=minimalProtocolFeeRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"minimal_protocol_fee_rate"`
	// is_instant_derivative_market_launch_enabled defines whether instant
	// derivative market launch is enabled
	IsInstantDerivativeMarketLaunchEnabled bool  `protobuf:"varint,24,opt,name=is_instant_derivative_market_launch_enabled,json=isInstantDerivativeMarketLaunchEnabled,proto3" json:"is_instant_derivative_market_launch_enabled,omitempty"`
	PostOnlyModeHeightThreshold            int64 `protobuf:"varint,25,opt,name=post_only_mode_height_threshold,json=postOnlyModeHeightThreshold,proto3" json:"post_only_mode_height_threshold,omitempty"`
	// Maximum time in seconds since the last mark price update to allow a
	// decrease in margin
	MarginDecreasePriceTimestampThresholdSeconds int64 `protobuf:"varint,26,opt,name=margin_decrease_price_timestamp_threshold_seconds,json=marginDecreasePriceTimestampThresholdSeconds,proto3" json:"margin_decrease_price_timestamp_threshold_seconds,omitempty"`
	// List of addresses that are allowed to perform exchange admin operations
	ExchangeAdmins []string `protobuf:"bytes,27,rep,name=exchange_admins,json=exchangeAdmins,proto3" json:"exchange_admins,omitempty"`
	// inj_auction_max_cap defines the maximum cap for INJ sent to auction
	InjAuctionMaxCap cosmossdk_io_math.Int `protobuf:"bytes,28,opt,name=inj_auction_max_cap,json=injAuctionMaxCap,proto3,customtype=cosmossdk.io/math.Int" json:"inj_auction_max_cap"`
}

func (m *Params) Reset()         { *m = Params{} }
func (m *Params) String() string { return proto.CompactTextString(m) }
func (*Params) ProtoMessage()    {}
func (*Params) Descriptor() ([]byte, []int) {
	return fileDescriptor_2116e2804e9c53f9, []int{0}
}
func (m *Params) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Params.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Params) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Params.Merge(m, src)
}
func (m *Params) XXX_Size() int {
	return m.Size()
}
func (m *Params) XXX_DiscardUnknown() {
	xxx_messageInfo_Params.DiscardUnknown(m)
}

var xxx_messageInfo_Params proto.InternalMessageInfo

func (m *Params) GetSpotMarketInstantListingFee() types.Coin {
	if m != nil {
		return m.SpotMarketInstantListingFee
	}
	return types.Coin{}
}

func (m *Params) GetDerivativeMarketInstantListingFee() types.Coin {
	if m != nil {
		return m.DerivativeMarketInstantListingFee
	}
	return types.Coin{}
}

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

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

func (m *Params) GetMaxDerivativeOrderSideCount() uint32 {
	if m != nil {
		return m.MaxDerivativeOrderSideCount
	}
	return 0
}

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

func (m *Params) GetBinaryOptionsMarketInstantListingFee() types.Coin {
	if m != nil {
		return m.BinaryOptionsMarketInstantListingFee
	}
	return types.Coin{}
}

func (m *Params) GetAtomicMarketOrderAccessLevel() AtomicMarketOrderAccessLevel {
	if m != nil {
		return m.AtomicMarketOrderAccessLevel
	}
	return AtomicMarketOrderAccessLevel_Nobody
}

func (m *Params) GetIsInstantDerivativeMarketLaunchEnabled() bool {
	if m != nil {
		return m.IsInstantDerivativeMarketLaunchEnabled
	}
	return false
}

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

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

func (m *Params) GetExchangeAdmins() []string {
	if m != nil {
		return m.ExchangeAdmins
	}
	return nil
}

type MarketFeeMultiplier struct {
	MarketId      string                      `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	FeeMultiplier cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=fee_multiplier,json=feeMultiplier,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"fee_multiplier"`
}

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

var xxx_messageInfo_MarketFeeMultiplier proto.InternalMessageInfo

// An object describing a derivative market in the Injective Futures Protocol.
type DerivativeMarket struct {
	// Ticker for the derivative contract.
	Ticker string `protobuf:"bytes,1,opt,name=ticker,proto3" json:"ticker,omitempty"`
	// Oracle base currency
	OracleBase string `protobuf:"bytes,2,opt,name=oracle_base,json=oracleBase,proto3" json:"oracle_base,omitempty"`
	// Oracle quote currency
	OracleQuote string `protobuf:"bytes,3,opt,name=oracle_quote,json=oracleQuote,proto3" json:"oracle_quote,omitempty"`
	// Oracle type
	OracleType types1.OracleType `protobuf:"varint,4,opt,name=oracle_type,json=oracleType,proto3,enum=injective.oracle.v1beta1.OracleType" json:"oracle_type,omitempty"`
	// Scale factor for oracle prices.
	OracleScaleFactor uint32 `protobuf:"varint,5,opt,name=oracle_scale_factor,json=oracleScaleFactor,proto3" json:"oracle_scale_factor,omitempty"`
	// Address of the quote currency denomination for the derivative contract
	QuoteDenom string `protobuf:"bytes,6,opt,name=quote_denom,json=quoteDenom,proto3" json:"quote_denom,omitempty"`
	// Unique market ID.
	MarketId string `protobuf:"bytes,7,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// initial_margin_ratio defines the initial margin ratio of a derivative
	// market
	InitialMarginRatio cosmossdk_io_math.LegacyDec `protobuf:"bytes,8,opt,name=initial_margin_ratio,json=initialMarginRatio,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"initial_margin_ratio"`
	// maintenance_margin_ratio defines the maintenance margin ratio of a
	// derivative market
	MaintenanceMarginRatio cosmossdk_io_math.LegacyDec `protobuf:"bytes,9,opt,name=maintenance_margin_ratio,json=maintenanceMarginRatio,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"maintenance_margin_ratio"`
	// maker_fee_rate defines the maker fee rate of a derivative market
	MakerFeeRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,10,opt,name=maker_fee_rate,json=makerFeeRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"maker_fee_rate"`
	// taker_fee_rate defines the taker fee rate of a derivative market
	TakerFeeRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,11,opt,name=taker_fee_rate,json=takerFeeRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"taker_fee_rate"`
	// relayer_fee_share_rate defines the percentage of the transaction fee shared
	// with the relayer in a derivative market
	RelayerFeeShareRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,12,opt,name=relayer_fee_share_rate,json=relayerFeeShareRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"relayer_fee_share_rate"`
	// true if the market is a perpetual market. false if the market is an expiry
	// futures market
	IsPerpetual bool `protobuf:"varint,13,opt,name=isPerpetual,proto3" json:"isPerpetual,omitempty"`
	// Status of the market
	Status MarketStatus `protobuf:"varint,14,opt,name=status,proto3,enum=injective.exchange.v1beta1.MarketStatus" json:"status,omitempty"`
	// min_price_tick_size defines the minimum tick size that the price and margin
	// required for orders in the market
	MinPriceTickSize cosmossdk_io_math.LegacyDec `protobuf:"bytes,15,opt,name=min_price_tick_size,json=minPriceTickSize,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"min_price_tick_size"`
	// min_quantity_tick_size defines the minimum tick size of the quantity
	// required for orders in the market
	MinQuantityTickSize cosmossdk_io_math.LegacyDec `protobuf:"bytes,16,opt,name=min_quantity_tick_size,json=minQuantityTickSize,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"min_quantity_tick_size"`
	// min_notional defines the minimum notional (in quote asset) required for
	// orders in the market
	MinNotional cosmossdk_io_math.LegacyDec `protobuf:"bytes,17,opt,name=min_notional,json=minNotional,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"min_notional"`
	// current market admin
	Admin string `protobuf:"bytes,18,opt,name=admin,proto3" json:"admin,omitempty"`
	// level of admin permissions
	AdminPermissions uint32 `protobuf:"varint,19,opt,name=admin_permissions,json=adminPermissions,proto3" json:"admin_permissions,omitempty"`
}

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

var xxx_messageInfo_DerivativeMarket proto.InternalMessageInfo

// An object describing a binary options market in Injective Protocol.
type BinaryOptionsMarket struct {
	// Ticker for the derivative contract.
	Ticker string `protobuf:"bytes,1,opt,name=ticker,proto3" json:"ticker,omitempty"`
	// Oracle symbol
	OracleSymbol string `protobuf:"bytes,2,opt,name=oracle_symbol,json=oracleSymbol,proto3" json:"oracle_symbol,omitempty"`
	// Oracle Provider
	OracleProvider string `protobuf:"bytes,3,opt,name=oracle_provider,json=oracleProvider,proto3" json:"oracle_provider,omitempty"`
	// Oracle type
	OracleType types1.OracleType `protobuf:"varint,4,opt,name=oracle_type,json=oracleType,proto3,enum=injective.oracle.v1beta1.OracleType" json:"oracle_type,omitempty"`
	// Scale factor for oracle prices.
	OracleScaleFactor uint32 `protobuf:"varint,5,opt,name=oracle_scale_factor,json=oracleScaleFactor,proto3" json:"oracle_scale_factor,omitempty"`
	// expiration timestamp
	ExpirationTimestamp int64 `protobuf:"varint,6,opt,name=expiration_timestamp,json=expirationTimestamp,proto3" json:"expiration_timestamp,omitempty"`
	// expiration timestamp
	SettlementTimestamp int64 `protobuf:"varint,7,opt,name=settlement_timestamp,json=settlementTimestamp,proto3" json:"settlement_timestamp,omitempty"`
	// admin of the market
	Admin string `protobuf:"bytes,8,opt,name=admin,proto3" json:"admin,omitempty"`
	// Address of the quote currency denomination for the binary options contract
	QuoteDenom string `protobuf:"bytes,9,opt,name=quote_denom,json=quoteDenom,proto3" json:"quote_denom,omitempty"`
	// Unique market ID.
	MarketId string `protobuf:"bytes,10,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// maker_fee_rate defines the maker fee rate of a binary options market
	MakerFeeRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,11,opt,name=maker_fee_rate,json=makerFeeRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"maker_fee_rate"`
	// taker_fee_rate defines the taker fee rate of a derivative market
	TakerFeeRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,12,opt,name=taker_fee_rate,json=takerFeeRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"taker_fee_rate"`
	// relayer_fee_share_rate defines the percentage of the transaction fee shared
	// with the relayer in a derivative market
	RelayerFeeShareRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,13,opt,name=relayer_fee_share_rate,json=relayerFeeShareRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"relayer_fee_share_rate"`
	// Status of the market
	Status MarketStatus `protobuf:"varint,14,opt,name=status,proto3,enum=injective.exchange.v1beta1.MarketStatus" json:"status,omitempty"`
	// min_price_tick_size defines the minimum tick size that the price and margin
	// required for orders in the market
	MinPriceTickSize cosmossdk_io_math.LegacyDec `protobuf:"bytes,15,opt,name=min_price_tick_size,json=minPriceTickSize,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"min_price_tick_size"`
	// min_quantity_tick_size defines the minimum tick size of the quantity
	// required for orders in the market
	MinQuantityTickSize cosmossdk_io_math.LegacyDec  `protobuf:"bytes,16,opt,name=min_quantity_tick_size,json=minQuantityTickSize,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"min_quantity_tick_size"`
	SettlementPrice     *cosmossdk_io_math.LegacyDec `protobuf:"bytes,17,opt,name=settlement_price,json=settlementPrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"settlement_price,omitempty"`
	// min_notional defines the minimum notional (in quote asset) required for
	// orders in the market
	MinNotional cosmossdk_io_math.LegacyDec `protobuf:"bytes,18,opt,name=min_notional,json=minNotional,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"min_notional"`
	// level of admin permissions
	AdminPermissions uint32 `protobuf:"varint,19,opt,name=admin_permissions,json=adminPermissions,proto3" json:"admin_permissions,omitempty"`
}

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

var xxx_messageInfo_BinaryOptionsMarket proto.InternalMessageInfo

type ExpiryFuturesMarketInfo struct {
	// market ID.
	MarketId string `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// expiration_timestamp defines the expiration time for a time expiry futures
	// market.
	ExpirationTimestamp int64 `protobuf:"varint,2,opt,name=expiration_timestamp,json=expirationTimestamp,proto3" json:"expiration_timestamp,omitempty"`
	// expiration_twap_start_timestamp defines the start time of the TWAP
	// calculation window
	TwapStartTimestamp int64 `protobuf:"varint,3,opt,name=twap_start_timestamp,json=twapStartTimestamp,proto3" json:"twap_start_timestamp,omitempty"`
	// expiration_twap_start_price_cumulative defines the cumulative price for the
	// start of the TWAP window
	ExpirationTwapStartPriceCumulative cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=expiration_twap_start_price_cumulative,json=expirationTwapStartPriceCumulative,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"expiration_twap_start_price_cumulative"`
	// settlement_price defines the settlement price for a time expiry futures
	// market.
	SettlementPrice cosmossdk_io_math.LegacyDec `protobuf:"bytes,5,opt,name=settlement_price,json=settlementPrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"settlement_price"`
}

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

var xxx_messageInfo_ExpiryFuturesMarketInfo proto.InternalMessageInfo

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

func (m *ExpiryFuturesMarketInfo) GetExpirationTimestamp() int64 {
	if m != nil {
		return m.ExpirationTimestamp
	}
	return 0
}

func (m *ExpiryFuturesMarketInfo) GetTwapStartTimestamp() int64 {
	if m != nil {
		return m.TwapStartTimestamp
	}
	return 0
}

type PerpetualMarketInfo struct {
	// market ID.
	MarketId string `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// hourly_funding_rate_cap defines the maximum absolute value of the hourly
	// funding rate
	HourlyFundingRateCap cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=hourly_funding_rate_cap,json=hourlyFundingRateCap,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"hourly_funding_rate_cap"`
	// hourly_interest_rate defines the hourly interest rate
	HourlyInterestRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,3,opt,name=hourly_interest_rate,json=hourlyInterestRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"hourly_interest_rate"`
	// next_funding_timestamp defines the next funding timestamp in seconds of a
	// perpetual market
	NextFundingTimestamp int64 `protobuf:"varint,4,opt,name=next_funding_timestamp,json=nextFundingTimestamp,proto3" json:"next_funding_timestamp,omitempty"`
	// funding_interval defines the next funding interval in seconds of a
	// perpetual market.
	FundingInterval int64 `protobuf:"varint,5,opt,name=funding_interval,json=fundingInterval,proto3" json:"funding_interval,omitempty"`
}

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

var xxx_messageInfo_PerpetualMarketInfo proto.InternalMessageInfo

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

func (m *PerpetualMarketInfo) GetNextFundingTimestamp() int64 {
	if m != nil {
		return m.NextFundingTimestamp
	}
	return 0
}

func (m *PerpetualMarketInfo) GetFundingInterval() int64 {
	if m != nil {
		return m.FundingInterval
	}
	return 0
}

type PerpetualMarketFunding struct {
	// cumulative_funding defines the cumulative funding of a perpetual market.
	CumulativeFunding cosmossdk_io_math.LegacyDec `protobuf:"bytes,1,opt,name=cumulative_funding,json=cumulativeFunding,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"cumulative_funding"`
	// cumulative_price defines the cumulative price for the current hour up to
	// the last timestamp
	CumulativePrice cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=cumulative_price,json=cumulativePrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"cumulative_price"`
	LastTimestamp   int64                       `protobuf:"varint,3,opt,name=last_timestamp,json=lastTimestamp,proto3" json:"last_timestamp,omitempty"`
}

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

var xxx_messageInfo_PerpetualMarketFunding proto.InternalMessageInfo

func (m *PerpetualMarketFunding) GetLastTimestamp() int64 {
	if m != nil {
		return m.LastTimestamp
	}
	return 0
}

type DerivativeMarketSettlementInfo struct {
	// market ID.
	MarketId string `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// settlement_price defines the settlement price
	SettlementPrice cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=settlement_price,json=settlementPrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"settlement_price"`
}

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

var xxx_messageInfo_DerivativeMarketSettlementInfo proto.InternalMessageInfo

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

type NextFundingTimestamp struct {
	NextTimestamp int64 `protobuf:"varint,1,opt,name=next_timestamp,json=nextTimestamp,proto3" json:"next_timestamp,omitempty"`
}

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

var xxx_messageInfo_NextFundingTimestamp proto.InternalMessageInfo

func (m *NextFundingTimestamp) GetNextTimestamp() int64 {
	if m != nil {
		return m.NextTimestamp
	}
	return 0
}

type MidPriceAndTOB struct {
	// mid price of the market
	MidPrice *cosmossdk_io_math.LegacyDec `protobuf:"bytes,1,opt,name=mid_price,json=midPrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"mid_price,omitempty"`
	// best buy price of the market
	BestBuyPrice *cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=best_buy_price,json=bestBuyPrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"best_buy_price,omitempty"`
	// best sell price of the market
	BestSellPrice *cosmossdk_io_math.LegacyDec `protobuf:"bytes,3,opt,name=best_sell_price,json=bestSellPrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"best_sell_price,omitempty"`
}

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

var xxx_messageInfo_MidPriceAndTOB proto.InternalMessageInfo

// An object describing trade pair of two assets.
type SpotMarket struct {
	// A name of the pair in format AAA/BBB, where AAA is base asset, BBB is quote
	// asset.
	Ticker string `protobuf:"bytes,1,opt,name=ticker,proto3" json:"ticker,omitempty"`
	// Coin denom used for the base asset
	BaseDenom string `protobuf:"bytes,2,opt,name=base_denom,json=baseDenom,proto3" json:"base_denom,omitempty"`
	// Coin used for the quote asset
	QuoteDenom string `protobuf:"bytes,3,opt,name=quote_denom,json=quoteDenom,proto3" json:"quote_denom,omitempty"`
	// maker_fee_rate defines the fee percentage makers pay when trading
	MakerFeeRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=maker_fee_rate,json=makerFeeRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"maker_fee_rate"`
	// taker_fee_rate defines the fee percentage takers pay when trading
	TakerFeeRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,5,opt,name=taker_fee_rate,json=takerFeeRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"taker_fee_rate"`
	// relayer_fee_share_rate defines the percentage of the transaction fee shared
	// with the relayer in a derivative market
	RelayerFeeShareRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,6,opt,name=relayer_fee_share_rate,json=relayerFeeShareRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"relayer_fee_share_rate"`
	// Unique market ID.
	MarketId string `protobuf:"bytes,7,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// Status of the market
	Status MarketStatus `protobuf:"varint,8,opt,name=status,proto3,enum=injective.exchange.v1beta1.MarketStatus" json:"status,omitempty"`
	// min_price_tick_size defines the minimum tick size that the price required
	// for orders in the market
	MinPriceTickSize cosmossdk_io_math.LegacyDec `protobuf:"bytes,9,opt,name=min_price_tick_size,json=minPriceTickSize,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"min_price_tick_size"`
	// min_quantity_tick_size defines the minimum tick size of the quantity
	// required for orders in the market
	MinQuantityTickSize cosmossdk_io_math.LegacyDec `protobuf:"bytes,10,opt,name=min_quantity_tick_size,json=minQuantityTickSize,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"min_quantity_tick_size"`
	// min_notional defines the minimum notional (in quote asset) required for
	// orders in the market
	MinNotional cosmossdk_io_math.LegacyDec `protobuf:"bytes,11,opt,name=min_notional,json=minNotional,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"min_notional"`
	// current market admin
	Admin string `protobuf:"bytes,12,opt,name=admin,proto3" json:"admin,omitempty"`
	// level of admin permissions
	AdminPermissions uint32 `protobuf:"varint,13,opt,name=admin_permissions,json=adminPermissions,proto3" json:"admin_permissions,omitempty"`
}

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

var xxx_messageInfo_SpotMarket proto.InternalMessageInfo

func (m *SpotMarket) GetTicker() string {
	if m != nil {
		return m.Ticker
	}
	return ""
}

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

func (m *SpotMarket) GetQuoteDenom() string {
	if m != nil {
		return m.QuoteDenom
	}
	return ""
}

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

func (m *SpotMarket) GetStatus() MarketStatus {
	if m != nil {
		return m.Status
	}
	return MarketStatus_Unspecified
}

func (m *SpotMarket) GetAdmin() string {
	if m != nil {
		return m.Admin
	}
	return ""
}

func (m *SpotMarket) GetAdminPermissions() uint32 {
	if m != nil {
		return m.AdminPermissions
	}
	return 0
}

// A subaccount's deposit for a given base currency
type Deposit struct {
	AvailableBalance cosmossdk_io_math.LegacyDec `protobuf:"bytes,1,opt,name=available_balance,json=availableBalance,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"available_balance"`
	TotalBalance     cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=total_balance,json=totalBalance,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"total_balance"`
}

func (m *Deposit) Reset()         { *m = Deposit{} }
func (m *Deposit) String() string { return proto.CompactTextString(m) }
func (*Deposit) ProtoMessage()    {}
func (*Deposit) Descriptor() ([]byte, []int) {
	return fileDescriptor_2116e2804e9c53f9, []int{11}
}
func (m *Deposit) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Deposit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Deposit.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Deposit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Deposit.Merge(m, src)
}
func (m *Deposit) XXX_Size() int {
	return m.Size()
}
func (m *Deposit) XXX_DiscardUnknown() {
	xxx_messageInfo_Deposit.DiscardUnknown(m)
}

var xxx_messageInfo_Deposit proto.InternalMessageInfo

type SubaccountTradeNonce struct {
	Nonce uint32 `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
}

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

var xxx_messageInfo_SubaccountTradeNonce proto.InternalMessageInfo

func (m *SubaccountTradeNonce) GetNonce() uint32 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

type OrderInfo struct {
	// bytes32 subaccount ID that created the order
	SubaccountId string `protobuf:"bytes,1,opt,name=subaccount_id,json=subaccountId,proto3" json:"subaccount_id,omitempty"`
	// address fee_recipient address that will receive fees for the order
	FeeRecipient string `protobuf:"bytes,2,opt,name=fee_recipient,json=feeRecipient,proto3" json:"fee_recipient,omitempty"`
	// price of the order
	Price cosmossdk_io_math.LegacyDec `protobuf:"bytes,3,opt,name=price,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"price"`
	// quantity of the order
	Quantity cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=quantity,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"quantity"`
	Cid      string                      `protobuf:"bytes,5,opt,name=cid,proto3" json:"cid,omitempty"`
}

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

var xxx_messageInfo_OrderInfo proto.InternalMessageInfo

func (m *OrderInfo) GetSubaccountId() string {
	if m != nil {
		return m.SubaccountId
	}
	return ""
}

func (m *OrderInfo) GetFeeRecipient() string {
	if m != nil {
		return m.FeeRecipient
	}
	return ""
}

func (m *OrderInfo) GetCid() string {
	if m != nil {
		return m.Cid
	}
	return ""
}

type SpotOrder struct {
	// market_id represents the unique ID of the market
	MarketId string `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// order_info contains the information of the order
	OrderInfo OrderInfo `protobuf:"bytes,2,opt,name=order_info,json=orderInfo,proto3" json:"order_info"`
	// order types
	OrderType OrderType `protobuf:"varint,3,opt,name=order_type,json=orderType,proto3,enum=injective.exchange.v1beta1.OrderType" json:"order_type,omitempty"`
	// trigger_price is the trigger price used by stop/take orders
	TriggerPrice *cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=trigger_price,json=triggerPrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"trigger_price,omitempty"`
}

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

var xxx_messageInfo_SpotOrder proto.InternalMessageInfo

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

func (m *SpotOrder) GetOrderInfo() OrderInfo {
	if m != nil {
		return m.OrderInfo
	}
	return OrderInfo{}
}

func (m *SpotOrder) GetOrderType() OrderType {
	if m != nil {
		return m.OrderType
	}
	return OrderType_UNSPECIFIED
}

// A valid Spot limit order with Metadata.
type SpotLimitOrder struct {
	// order_info contains the information of the order
	OrderInfo OrderInfo `protobuf:"bytes,1,opt,name=order_info,json=orderInfo,proto3" json:"order_info"`
	// order types
	OrderType OrderType `protobuf:"varint,2,opt,name=order_type,json=orderType,proto3,enum=injective.exchange.v1beta1.OrderType" json:"order_type,omitempty"`
	// the amount of the quantity remaining fillable
	Fillable cosmossdk_io_math.LegacyDec `protobuf:"bytes,3,opt,name=fillable,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"fillable"`
	// trigger_price is the trigger price used by stop/take orders
	TriggerPrice *cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=trigger_price,json=triggerPrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"trigger_price,omitempty"`
	OrderHash    []byte                       `protobuf:"bytes,5,opt,name=order_hash,json=orderHash,proto3" json:"order_hash,omitempty"`
}

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

var xxx_messageInfo_SpotLimitOrder proto.InternalMessageInfo

func (m *SpotLimitOrder) GetOrderInfo() OrderInfo {
	if m != nil {
		return m.OrderInfo
	}
	return OrderInfo{}
}

func (m *SpotLimitOrder) GetOrderType() OrderType {
	if m != nil {
		return m.OrderType
	}
	return OrderType_UNSPECIFIED
}

func (m *SpotLimitOrder) GetOrderHash() []byte {
	if m != nil {
		return m.OrderHash
	}
	return nil
}

// A valid Spot market order with Metadata.
type SpotMarketOrder struct {
	// order_info contains the information of the order
	OrderInfo   OrderInfo                   `protobuf:"bytes,1,opt,name=order_info,json=orderInfo,proto3" json:"order_info"`
	BalanceHold cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=balance_hold,json=balanceHold,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"balance_hold"`
	OrderHash   []byte                      `protobuf:"bytes,3,opt,name=order_hash,json=orderHash,proto3" json:"order_hash,omitempty"`
	// order types
	OrderType OrderType `protobuf:"varint,4,opt,name=order_type,json=orderType,proto3,enum=injective.exchange.v1beta1.OrderType" json:"order_type,omitempty"`
	// trigger_price is the trigger price used by stop/take orders
	TriggerPrice *cosmossdk_io_math.LegacyDec `protobuf:"bytes,5,opt,name=trigger_price,json=triggerPrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"trigger_price,omitempty"`
}

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

var xxx_messageInfo_SpotMarketOrder proto.InternalMessageInfo

func (m *SpotMarketOrder) GetOrderInfo() OrderInfo {
	if m != nil {
		return m.OrderInfo
	}
	return OrderInfo{}
}

func (m *SpotMarketOrder) GetOrderHash() []byte {
	if m != nil {
		return m.OrderHash
	}
	return nil
}

func (m *SpotMarketOrder) GetOrderType() OrderType {
	if m != nil {
		return m.OrderType
	}
	return OrderType_UNSPECIFIED
}

type DerivativeOrder struct {
	// market_id represents the unique ID of the market
	MarketId string `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// order_info contains the information of the order
	OrderInfo OrderInfo `protobuf:"bytes,2,opt,name=order_info,json=orderInfo,proto3" json:"order_info"`
	// order types
	OrderType OrderType `protobuf:"varint,3,opt,name=order_type,json=orderType,proto3,enum=injective.exchange.v1beta1.OrderType" json:"order_type,omitempty"`
	// margin is the margin used by the limit order
	Margin cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=margin,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"margin"`
	// trigger_price is the trigger price used by stop/take orders
	TriggerPrice *cosmossdk_io_math.LegacyDec `protobuf:"bytes,5,opt,name=trigger_price,json=triggerPrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"trigger_price,omitempty"`
}

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

var xxx_messageInfo_DerivativeOrder proto.InternalMessageInfo

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

func (m *DerivativeOrder) GetOrderInfo() OrderInfo {
	if m != nil {
		return m.OrderInfo
	}
	return OrderInfo{}
}

func (m *DerivativeOrder) GetOrderType() OrderType {
	if m != nil {
		return m.OrderType
	}
	return OrderType_UNSPECIFIED
}

type SubaccountOrderbookMetadata struct {
	VanillaLimitOrderCount    uint32 `protobuf:"varint,1,opt,name=vanilla_limit_order_count,json=vanillaLimitOrderCount,proto3" json:"vanilla_limit_order_count,omitempty"`
	ReduceOnlyLimitOrderCount uint32 `protobuf:"varint,2,opt,name=reduce_only_limit_order_count,json=reduceOnlyLimitOrderCount,proto3" json:"reduce_only_limit_order_count,omitempty"`
	// AggregateReduceOnlyQuantity is the aggregate fillable quantity of the
	// subaccount's reduce-only limit orders in the given direction.
	AggregateReduceOnlyQuantity cosmossdk_io_math.LegacyDec `protobuf:"bytes,3,opt,name=aggregate_reduce_only_quantity,json=aggregateReduceOnlyQuantity,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"aggregate_reduce_only_quantity"`
	// AggregateVanillaQuantity is the aggregate fillable quantity of the
	// subaccount's vanilla limit orders in the given direction.
	AggregateVanillaQuantity        cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=aggregate_vanilla_quantity,json=aggregateVanillaQuantity,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"aggregate_vanilla_quantity"`
	VanillaConditionalOrderCount    uint32                      `protobuf:"varint,5,opt,name=vanilla_conditional_order_count,json=vanillaConditionalOrderCount,proto3" json:"vanilla_conditional_order_count,omitempty"`
	ReduceOnlyConditionalOrderCount uint32                      `protobuf:"varint,6,opt,name=reduce_only_conditional_order_count,json=reduceOnlyConditionalOrderCount,proto3" json:"reduce_only_conditional_order_count,omitempty"`
}

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

var xxx_messageInfo_SubaccountOrderbookMetadata proto.InternalMessageInfo

func (m *SubaccountOrderbookMetadata) GetVanillaLimitOrderCount() uint32 {
	if m != nil {
		return m.VanillaLimitOrderCount
	}
	return 0
}

func (m *SubaccountOrderbookMetadata) GetReduceOnlyLimitOrderCount() uint32 {
	if m != nil {
		return m.ReduceOnlyLimitOrderCount
	}
	return 0
}

func (m *SubaccountOrderbookMetadata) GetVanillaConditionalOrderCount() uint32 {
	if m != nil {
		return m.VanillaConditionalOrderCount
	}
	return 0
}

func (m *SubaccountOrderbookMetadata) GetReduceOnlyConditionalOrderCount() uint32 {
	if m != nil {
		return m.ReduceOnlyConditionalOrderCount
	}
	return 0
}

type SubaccountOrder struct {
	// price of the order
	Price cosmossdk_io_math.LegacyDec `protobuf:"bytes,1,opt,name=price,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"price"`
	// the amount of the quantity remaining fillable
	Quantity     cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=quantity,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"quantity"`
	IsReduceOnly bool                        `protobuf:"varint,3,opt,name=isReduceOnly,proto3" json:"isReduceOnly,omitempty"`
	Cid          string                      `protobuf:"bytes,4,opt,name=cid,proto3" json:"cid,omitempty"`
}

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

var xxx_messageInfo_SubaccountOrder proto.InternalMessageInfo

func (m *SubaccountOrder) GetIsReduceOnly() bool {
	if m != nil {
		return m.IsReduceOnly
	}
	return false
}

func (m *SubaccountOrder) GetCid() string {
	if m != nil {
		return m.Cid
	}
	return ""
}

type SubaccountOrderData struct {
	Order     *SubaccountOrder `protobuf:"bytes,1,opt,name=order,proto3" json:"order,omitempty"`
	OrderHash []byte           `protobuf:"bytes,2,opt,name=order_hash,json=orderHash,proto3" json:"order_hash,omitempty"`
}

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

var xxx_messageInfo_SubaccountOrderData proto.InternalMessageInfo

func (m *SubaccountOrderData) GetOrder() *SubaccountOrder {
	if m != nil {
		return m.Order
	}
	return nil
}

func (m *SubaccountOrderData) GetOrderHash() []byte {
	if m != nil {
		return m.OrderHash
	}
	return nil
}

// A valid Derivative limit order with Metadata.
type DerivativeLimitOrder struct {
	// order_info contains the information of the order
	OrderInfo OrderInfo `protobuf:"bytes,1,opt,name=order_info,json=orderInfo,proto3" json:"order_info"`
	// order types
	OrderType OrderType `protobuf:"varint,2,opt,name=order_type,json=orderType,proto3,enum=injective.exchange.v1beta1.OrderType" json:"order_type,omitempty"`
	// margin is the margin used by the limit order
	Margin cosmossdk_io_math.LegacyDec `protobuf:"bytes,3,opt,name=margin,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"margin"`
	// the amount of the quantity remaining fillable
	Fillable cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=fillable,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"fillable"`
	// trigger_price is the trigger price used by stop/take orders
	TriggerPrice *cosmossdk_io_math.LegacyDec `protobuf:"bytes,5,opt,name=trigger_price,json=triggerPrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"trigger_price,omitempty"`
	OrderHash    []byte                       `protobuf:"bytes,6,opt,name=order_hash,json=orderHash,proto3" json:"order_hash,omitempty"`
}

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

var xxx_messageInfo_DerivativeLimitOrder proto.InternalMessageInfo

func (m *DerivativeLimitOrder) GetOrderInfo() OrderInfo {
	if m != nil {
		return m.OrderInfo
	}
	return OrderInfo{}
}

func (m *DerivativeLimitOrder) GetOrderType() OrderType {
	if m != nil {
		return m.OrderType
	}
	return OrderType_UNSPECIFIED
}

func (m *DerivativeLimitOrder) GetOrderHash() []byte {
	if m != nil {
		return m.OrderHash
	}
	return nil
}

// A valid Derivative market order with Metadata.
type DerivativeMarketOrder struct {
	// order_info contains the information of the order
	OrderInfo OrderInfo `protobuf:"bytes,1,opt,name=order_info,json=orderInfo,proto3" json:"order_info"`
	// order types
	OrderType  OrderType                   `protobuf:"varint,2,opt,name=order_type,json=orderType,proto3,enum=injective.exchange.v1beta1.OrderType" json:"order_type,omitempty"`
	Margin     cosmossdk_io_math.LegacyDec `protobuf:"bytes,3,opt,name=margin,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"margin"`
	MarginHold cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=margin_hold,json=marginHold,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"margin_hold"`
	// trigger_price is the trigger price used by stop/take orders
	TriggerPrice *cosmossdk_io_math.LegacyDec `protobuf:"bytes,5,opt,name=trigger_price,json=triggerPrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"trigger_price,omitempty"`
	OrderHash    []byte                       `protobuf:"bytes,6,opt,name=order_hash,json=orderHash,proto3" json:"order_hash,omitempty"`
}

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

var xxx_messageInfo_DerivativeMarketOrder proto.InternalMessageInfo

func (m *DerivativeMarketOrder) GetOrderInfo() OrderInfo {
	if m != nil {
		return m.OrderInfo
	}
	return OrderInfo{}
}

func (m *DerivativeMarketOrder) GetOrderType() OrderType {
	if m != nil {
		return m.OrderType
	}
	return OrderType_UNSPECIFIED
}

func (m *DerivativeMarketOrder) GetOrderHash() []byte {
	if m != nil {
		return m.OrderHash
	}
	return nil
}

type Position struct {
	IsLong                 bool                        `protobuf:"varint,1,opt,name=isLong,proto3" json:"isLong,omitempty"`
	Quantity               cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=quantity,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"quantity"`
	EntryPrice             cosmossdk_io_math.LegacyDec `protobuf:"bytes,3,opt,name=entry_price,json=entryPrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"entry_price"`
	Margin                 cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=margin,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"margin"`
	CumulativeFundingEntry cosmossdk_io_math.LegacyDec `protobuf:"bytes,5,opt,name=cumulative_funding_entry,json=cumulativeFundingEntry,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"cumulative_funding_entry"`
}

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

var xxx_messageInfo_Position proto.InternalMessageInfo

func (m *Position) GetIsLong() bool {
	if m != nil {
		return m.IsLong
	}
	return false
}

type MarketOrderIndicator struct {
	// market_id represents the unique ID of the market
	MarketId string `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	IsBuy    bool   `protobuf:"varint,2,opt,name=isBuy,proto3" json:"isBuy,omitempty"`
}

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

var xxx_messageInfo_MarketOrderIndicator proto.InternalMessageInfo

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

func (m *MarketOrderIndicator) GetIsBuy() bool {
	if m != nil {
		return m.IsBuy
	}
	return false
}

type TradeLog struct {
	Quantity cosmossdk_io_math.LegacyDec `protobuf:"bytes,1,opt,name=quantity,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"quantity"`
	Price    cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=price,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"price"`
	// bytes32 subaccount ID that executed the trade
	SubaccountId        []byte                      `protobuf:"bytes,3,opt,name=subaccount_id,json=subaccountId,proto3" json:"subaccount_id,omitempty"`
	Fee                 cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=fee,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"fee"`
	OrderHash           []byte                      `protobuf:"bytes,5,opt,name=order_hash,json=orderHash,proto3" json:"order_hash,omitempty"`
	FeeRecipientAddress []byte                      `protobuf:"bytes,6,opt,name=fee_recipient_address,json=feeRecipientAddress,proto3" json:"fee_recipient_address,omitempty"`
	Cid                 string                      `protobuf:"bytes,7,opt,name=cid,proto3" json:"cid,omitempty"`
}

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

var xxx_messageInfo_TradeLog proto.InternalMessageInfo

func (m *TradeLog) GetSubaccountId() []byte {
	if m != nil {
		return m.SubaccountId
	}
	return nil
}

func (m *TradeLog) GetOrderHash() []byte {
	if m != nil {
		return m.OrderHash
	}
	return nil
}

func (m *TradeLog) GetFeeRecipientAddress() []byte {
	if m != nil {
		return m.FeeRecipientAddress
	}
	return nil
}

func (m *TradeLog) GetCid() string {
	if m != nil {
		return m.Cid
	}
	return ""
}

type PositionDelta struct {
	IsLong            bool                        `protobuf:"varint,1,opt,name=is_long,json=isLong,proto3" json:"is_long,omitempty"`
	ExecutionQuantity cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=execution_quantity,json=executionQuantity,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"execution_quantity"`
	ExecutionMargin   cosmossdk_io_math.LegacyDec `protobuf:"bytes,3,opt,name=execution_margin,json=executionMargin,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"execution_margin"`
	ExecutionPrice    cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=execution_price,json=executionPrice,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"execution_price"`
}

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

var xxx_messageInfo_PositionDelta proto.InternalMessageInfo

func (m *PositionDelta) GetIsLong() bool {
	if m != nil {
		return m.IsLong
	}
	return false
}

type DerivativeTradeLog struct {
	SubaccountId        []byte                      `protobuf:"bytes,1,opt,name=subaccount_id,json=subaccountId,proto3" json:"subaccount_id,omitempty"`
	PositionDelta       *PositionDelta              `protobuf:"bytes,2,opt,name=position_delta,json=positionDelta,proto3" json:"position_delta,omitempty"`
	Payout              cosmossdk_io_math.LegacyDec `protobuf:"bytes,3,opt,name=payout,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"payout"`
	Fee                 cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=fee,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"fee"`
	OrderHash           []byte                      `protobuf:"bytes,5,opt,name=order_hash,json=orderHash,proto3" json:"order_hash,omitempty"`
	FeeRecipientAddress []byte                      `protobuf:"bytes,6,opt,name=fee_recipient_address,json=feeRecipientAddress,proto3" json:"fee_recipient_address,omitempty"`
	Cid                 string                      `protobuf:"bytes,7,opt,name=cid,proto3" json:"cid,omitempty"`
	Pnl                 cosmossdk_io_math.LegacyDec `protobuf:"bytes,8,opt,name=pnl,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"pnl"`
}

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

var xxx_messageInfo_DerivativeTradeLog proto.InternalMessageInfo

func (m *DerivativeTradeLog) GetSubaccountId() []byte {
	if m != nil {
		return m.SubaccountId
	}
	return nil
}

func (m *DerivativeTradeLog) GetPositionDelta() *PositionDelta {
	if m != nil {
		return m.PositionDelta
	}
	return nil
}

func (m *DerivativeTradeLog) GetOrderHash() []byte {
	if m != nil {
		return m.OrderHash
	}
	return nil
}

func (m *DerivativeTradeLog) GetFeeRecipientAddress() []byte {
	if m != nil {
		return m.FeeRecipientAddress
	}
	return nil
}

func (m *DerivativeTradeLog) GetCid() string {
	if m != nil {
		return m.Cid
	}
	return ""
}

type SubaccountPosition struct {
	Position     *Position `protobuf:"bytes,1,opt,name=position,proto3" json:"position,omitempty"`
	SubaccountId []byte    `protobuf:"bytes,2,opt,name=subaccount_id,json=subaccountId,proto3" json:"subaccount_id,omitempty"`
}

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

var xxx_messageInfo_SubaccountPosition proto.InternalMessageInfo

func (m *SubaccountPosition) GetPosition() *Position {
	if m != nil {
		return m.Position
	}
	return nil
}

func (m *SubaccountPosition) GetSubaccountId() []byte {
	if m != nil {
		return m.SubaccountId
	}
	return nil
}

type SubaccountDeposit struct {
	SubaccountId []byte   `protobuf:"bytes,1,opt,name=subaccount_id,json=subaccountId,proto3" json:"subaccount_id,omitempty"`
	Deposit      *Deposit `protobuf:"bytes,2,opt,name=deposit,proto3" json:"deposit,omitempty"`
}

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

var xxx_messageInfo_SubaccountDeposit proto.InternalMessageInfo

func (m *SubaccountDeposit) GetSubaccountId() []byte {
	if m != nil {
		return m.SubaccountId
	}
	return nil
}

func (m *SubaccountDeposit) GetDeposit() *Deposit {
	if m != nil {
		return m.Deposit
	}
	return nil
}

type DepositUpdate struct {
	Denom    string               `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
	Deposits []*SubaccountDeposit `protobuf:"bytes,2,rep,name=deposits,proto3" json:"deposits,omitempty"`
}

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

var xxx_messageInfo_DepositUpdate proto.InternalMessageInfo

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

func (m *DepositUpdate) GetDeposits() []*SubaccountDeposit {
	if m != nil {
		return m.Deposits
	}
	return nil
}

type PointsMultiplier struct {
	MakerPointsMultiplier cosmossdk_io_math.LegacyDec `protobuf:"bytes,1,opt,name=maker_points_multiplier,json=makerPointsMultiplier,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"maker_points_multiplier"`
	TakerPointsMultiplier cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=taker_points_multiplier,json=takerPointsMultiplier,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"taker_points_multiplier"`
}

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

var xxx_messageInfo_PointsMultiplier proto.InternalMessageInfo

type TradingRewardCampaignBoostInfo struct {
	BoostedSpotMarketIds        []string           `protobuf:"bytes,1,rep,name=boosted_spot_market_ids,json=boostedSpotMarketIds,proto3" json:"boosted_spot_market_ids,omitempty"`
	SpotMarketMultipliers       []PointsMultiplier `protobuf:"bytes,2,rep,name=spot_market_multipliers,json=spotMarketMultipliers,proto3" json:"spot_market_multipliers"`
	BoostedDerivativeMarketIds  []string           `protobuf:"bytes,3,rep,name=boosted_derivative_market_ids,json=boostedDerivativeMarketIds,proto3" json:"boosted_derivative_market_ids,omitempty"`
	DerivativeMarketMultipliers []PointsMultiplier `protobuf:"bytes,4,rep,name=derivative_market_multipliers,json=derivativeMarketMultipliers,proto3" json:"derivative_market_multipliers"`
}

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

var xxx_messageInfo_TradingRewardCampaignBoostInfo proto.InternalMessageInfo

func (m *TradingRewardCampaignBoostInfo) GetBoostedSpotMarketIds() []string {
	if m != nil {
		return m.BoostedSpotMarketIds
	}
	return nil
}

func (m *TradingRewardCampaignBoostInfo) GetSpotMarketMultipliers() []PointsMultiplier {
	if m != nil {
		return m.SpotMarketMultipliers
	}
	return nil
}

func (m *TradingRewardCampaignBoostInfo) GetBoostedDerivativeMarketIds() []string {
	if m != nil {
		return m.BoostedDerivativeMarketIds
	}
	return nil
}

func (m *TradingRewardCampaignBoostInfo) GetDerivativeMarketMultipliers() []PointsMultiplier {
	if m != nil {
		return m.DerivativeMarketMultipliers
	}
	return nil
}

type CampaignRewardPool struct {
	StartTimestamp int64 `protobuf:"varint,1,opt,name=start_timestamp,json=startTimestamp,proto3" json:"start_timestamp,omitempty"`
	// max_campaign_rewards are the maximum reward amounts to be disbursed at the
	// end of the campaign
	MaxCampaignRewards github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=max_campaign_rewards,json=maxCampaignRewards,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"max_campaign_rewards"`
}

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

var xxx_messageInfo_CampaignRewardPool proto.InternalMessageInfo

func (m *CampaignRewardPool) GetStartTimestamp() int64 {
	if m != nil {
		return m.StartTimestamp
	}
	return 0
}

func (m *CampaignRewardPool) GetMaxCampaignRewards() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.MaxCampaignRewards
	}
	return nil
}

type TradingRewardCampaignInfo struct {
	// number of seconds of the duration of each campaign
	CampaignDurationSeconds int64 `protobuf:"varint,1,opt,name=campaign_duration_seconds,json=campaignDurationSeconds,proto3" json:"campaign_duration_seconds,omitempty"`
	// the trading fee quote denoms which will be counted for the rewards
	QuoteDenoms []string `protobuf:"bytes,2,rep,name=quote_denoms,json=quoteDenoms,proto3" json:"quote_denoms,omitempty"`
	// the optional boost info for markets
	TradingRewardBoostInfo *TradingRewardCampaignBoostInfo `protobuf:"bytes,3,opt,name=trading_reward_boost_info,json=tradingRewardBoostInfo,proto3" json:"trading_reward_boost_info,omitempty"`
	// the marketIDs which are disqualified from being rewarded
	DisqualifiedMarketIds []string `protobuf:"bytes,4,rep,name=disqualified_market_ids,json=disqualifiedMarketIds,proto3" json:"disqualified_market_ids,omitempty"`
}

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

var xxx_messageInfo_TradingRewardCampaignInfo proto.InternalMessageInfo

func (m *TradingRewardCampaignInfo) GetCampaignDurationSeconds() int64 {
	if m != nil {
		return m.CampaignDurationSeconds
	}
	return 0
}

func (m *TradingRewardCampaignInfo) GetQuoteDenoms() []string {
	if m != nil {
		return m.QuoteDenoms
	}
	return nil
}

func (m *TradingRewardCampaignInfo) GetTradingRewardBoostInfo() *TradingRewardCampaignBoostInfo {
	if m != nil {
		return m.TradingRewardBoostInfo
	}
	return nil
}

func (m *TradingRewardCampaignInfo) GetDisqualifiedMarketIds() []string {
	if m != nil {
		return m.DisqualifiedMarketIds
	}
	return nil
}

type FeeDiscountTierInfo struct {
	MakerDiscountRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,1,opt,name=maker_discount_rate,json=makerDiscountRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"maker_discount_rate"`
	TakerDiscountRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=taker_discount_rate,json=takerDiscountRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"taker_discount_rate"`
	StakedAmount      cosmossdk_io_math.Int       `protobuf:"bytes,3,opt,name=staked_amount,json=stakedAmount,proto3,customtype=cosmossdk.io/math.Int" json:"staked_amount"`
	Volume            cosmossdk_io_math.LegacyDec `protobuf:"bytes,4,opt,name=volume,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"volume"`
}

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

var xxx_messageInfo_FeeDiscountTierInfo proto.InternalMessageInfo

type FeeDiscountSchedule struct {
	BucketCount    uint64 `protobuf:"varint,1,opt,name=bucket_count,json=bucketCount,proto3" json:"bucket_count,omitempty"`
	BucketDuration int64  `protobuf:"varint,2,opt,name=bucket_duration,json=bucketDuration,proto3" json:"bucket_duration,omitempty"`
	// the trading fee quote denoms which will be counted for the fee paid
	// contribution
	QuoteDenoms []string `protobuf:"bytes,3,rep,name=quote_denoms,json=quoteDenoms,proto3" json:"quote_denoms,omitempty"`
	// the fee discount tiers
	TierInfos []*FeeDiscountTierInfo `protobuf:"bytes,4,rep,name=tier_infos,json=tierInfos,proto3" json:"tier_infos,omitempty"`
	// the marketIDs which are disqualified from contributing to the fee paid
	// amount
	DisqualifiedMarketIds []string `protobuf:"bytes,5,rep,name=disqualified_market_ids,json=disqualifiedMarketIds,proto3" json:"disqualified_market_ids,omitempty"`
}

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

var xxx_messageInfo_FeeDiscountSchedule proto.InternalMessageInfo

func (m *FeeDiscountSchedule) GetBucketCount() uint64 {
	if m != nil {
		return m.BucketCount
	}
	return 0
}

func (m *FeeDiscountSchedule) GetBucketDuration() int64 {
	if m != nil {
		return m.BucketDuration
	}
	return 0
}

func (m *FeeDiscountSchedule) GetQuoteDenoms() []string {
	if m != nil {
		return m.QuoteDenoms
	}
	return nil
}

func (m *FeeDiscountSchedule) GetTierInfos() []*FeeDiscountTierInfo {
	if m != nil {
		return m.TierInfos
	}
	return nil
}

func (m *FeeDiscountSchedule) GetDisqualifiedMarketIds() []string {
	if m != nil {
		return m.DisqualifiedMarketIds
	}
	return nil
}

type FeeDiscountTierTTL struct {
	Tier         uint64 `protobuf:"varint,1,opt,name=tier,proto3" json:"tier,omitempty"`
	TtlTimestamp int64  `protobuf:"varint,2,opt,name=ttl_timestamp,json=ttlTimestamp,proto3" json:"ttl_timestamp,omitempty"`
}

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

var xxx_messageInfo_FeeDiscountTierTTL proto.InternalMessageInfo

func (m *FeeDiscountTierTTL) GetTier() uint64 {
	if m != nil {
		return m.Tier
	}
	return 0
}

func (m *FeeDiscountTierTTL) GetTtlTimestamp() int64 {
	if m != nil {
		return m.TtlTimestamp
	}
	return 0
}

type VolumeRecord struct {
	MakerVolume cosmossdk_io_math.LegacyDec `protobuf:"bytes,1,opt,name=maker_volume,json=makerVolume,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"maker_volume"`
	TakerVolume cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=taker_volume,json=takerVolume,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"taker_volume"`
}

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

var xxx_messageInfo_VolumeRecord proto.InternalMessageInfo

type AccountRewards struct {
	Account string                                   `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	Rewards github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=rewards,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"rewards"`
}

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

var xxx_messageInfo_AccountRewards proto.InternalMessageInfo

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

func (m *AccountRewards) GetRewards() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Rewards
	}
	return nil
}

type TradeRecords struct {
	MarketId           string         `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	LatestTradeRecords []*TradeRecord `protobuf:"bytes,2,rep,name=latest_trade_records,json=latestTradeRecords,proto3" json:"latest_trade_records,omitempty"`
}

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

var xxx_messageInfo_TradeRecords proto.InternalMessageInfo

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

func (m *TradeRecords) GetLatestTradeRecords() []*TradeRecord {
	if m != nil {
		return m.LatestTradeRecords
	}
	return nil
}

type SubaccountIDs struct {
	SubaccountIds [][]byte `protobuf:"bytes,1,rep,name=subaccount_ids,json=subaccountIds,proto3" json:"subaccount_ids,omitempty"`
}

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

var xxx_messageInfo_SubaccountIDs proto.InternalMessageInfo

func (m *SubaccountIDs) GetSubaccountIds() [][]byte {
	if m != nil {
		return m.SubaccountIds
	}
	return nil
}

type TradeRecord struct {
	Timestamp int64                       `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Price     cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=price,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"price"`
	Quantity  cosmossdk_io_math.LegacyDec `protobuf:"bytes,3,opt,name=quantity,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"quantity"`
}

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

var xxx_messageInfo_TradeRecord proto.InternalMessageInfo

func (m *TradeRecord) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

type Level struct {
	// price
	P cosmossdk_io_math.LegacyDec `protobuf:"bytes,1,opt,name=p,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"p"`
	// quantity
	Q cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=q,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"q"`
}

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

var xxx_messageInfo_Level proto.InternalMessageInfo

type AggregateSubaccountVolumeRecord struct {
	SubaccountId  string          `protobuf:"bytes,1,opt,name=subaccount_id,json=subaccountId,proto3" json:"subaccount_id,omitempty"`
	MarketVolumes []*MarketVolume `protobuf:"bytes,2,rep,name=market_volumes,json=marketVolumes,proto3" json:"market_volumes,omitempty"`
}

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

var xxx_messageInfo_AggregateSubaccountVolumeRecord proto.InternalMessageInfo

func (m *AggregateSubaccountVolumeRecord) GetSubaccountId() string {
	if m != nil {
		return m.SubaccountId
	}
	return ""
}

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

type AggregateAccountVolumeRecord struct {
	Account       string          `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	MarketVolumes []*MarketVolume `protobuf:"bytes,2,rep,name=market_volumes,json=marketVolumes,proto3" json:"market_volumes,omitempty"`
}

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

var xxx_messageInfo_AggregateAccountVolumeRecord proto.InternalMessageInfo

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

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

type MarketVolume struct {
	MarketId string       `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	Volume   VolumeRecord `protobuf:"bytes,2,opt,name=volume,proto3" json:"volume"`
}

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

var xxx_messageInfo_MarketVolume proto.InternalMessageInfo

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

func (m *MarketVolume) GetVolume() VolumeRecord {
	if m != nil {
		return m.Volume
	}
	return VolumeRecord{}
}

type DenomDecimals struct {
	Denom    string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
	Decimals uint64 `protobuf:"varint,2,opt,name=decimals,proto3" json:"decimals,omitempty"`
}

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

var xxx_messageInfo_DenomDecimals proto.InternalMessageInfo

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

func (m *DenomDecimals) GetDecimals() uint64 {
	if m != nil {
		return m.Decimals
	}
	return 0
}

type GrantAuthorization struct {
	Grantee string                `protobuf:"bytes,1,opt,name=grantee,proto3" json:"grantee,omitempty"`
	Amount  cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
}

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

var xxx_messageInfo_GrantAuthorization proto.InternalMessageInfo

func (m *GrantAuthorization) GetGrantee() string {
	if m != nil {
		return m.Grantee
	}
	return ""
}

type ActiveGrant struct {
	Granter string                `protobuf:"bytes,1,opt,name=granter,proto3" json:"granter,omitempty"`
	Amount  cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
}

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

var xxx_messageInfo_ActiveGrant proto.InternalMessageInfo

func (m *ActiveGrant) GetGranter() string {
	if m != nil {
		return m.Granter
	}
	return ""
}

type EffectiveGrant struct {
	Granter         string                `protobuf:"bytes,1,opt,name=granter,proto3" json:"granter,omitempty"`
	NetGrantedStake cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=net_granted_stake,json=netGrantedStake,proto3,customtype=cosmossdk.io/math.Int" json:"net_granted_stake"`
	IsValid         bool                  `protobuf:"varint,3,opt,name=is_valid,json=isValid,proto3" json:"is_valid,omitempty"`
}

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

var xxx_messageInfo_EffectiveGrant proto.InternalMessageInfo

func (m *EffectiveGrant) GetGranter() string {
	if m != nil {
		return m.Granter
	}
	return ""
}

func (m *EffectiveGrant) GetIsValid() bool {
	if m != nil {
		return m.IsValid
	}
	return false
}

func init() {
	proto.RegisterEnum("injective.exchange.v1beta1.AtomicMarketOrderAccessLevel", AtomicMarketOrderAccessLevel_name, AtomicMarketOrderAccessLevel_value)
	proto.RegisterEnum("injective.exchange.v1beta1.MarketStatus", MarketStatus_name, MarketStatus_value)
	proto.RegisterEnum("injective.exchange.v1beta1.OrderType", OrderType_name, OrderType_value)
	proto.RegisterEnum("injective.exchange.v1beta1.ExecutionType", ExecutionType_name, ExecutionType_value)
	proto.RegisterEnum("injective.exchange.v1beta1.OrderMask", OrderMask_name, OrderMask_value)
	proto.RegisterType((*Params)(nil), "injective.exchange.v1beta1.Params")
	proto.RegisterType((*MarketFeeMultiplier)(nil), "injective.exchange.v1beta1.MarketFeeMultiplier")
	proto.RegisterType((*DerivativeMarket)(nil), "injective.exchange.v1beta1.DerivativeMarket")
	proto.RegisterType((*BinaryOptionsMarket)(nil), "injective.exchange.v1beta1.BinaryOptionsMarket")
	proto.RegisterType((*ExpiryFuturesMarketInfo)(nil), "injective.exchange.v1beta1.ExpiryFuturesMarketInfo")
	proto.RegisterType((*PerpetualMarketInfo)(nil), "injective.exchange.v1beta1.PerpetualMarketInfo")
	proto.RegisterType((*PerpetualMarketFunding)(nil), "injective.exchange.v1beta1.PerpetualMarketFunding")
	proto.RegisterType((*DerivativeMarketSettlementInfo)(nil), "injective.exchange.v1beta1.DerivativeMarketSettlementInfo")
	proto.RegisterType((*NextFundingTimestamp)(nil), "injective.exchange.v1beta1.NextFundingTimestamp")
	proto.RegisterType((*MidPriceAndTOB)(nil), "injective.exchange.v1beta1.MidPriceAndTOB")
	proto.RegisterType((*SpotMarket)(nil), "injective.exchange.v1beta1.SpotMarket")
	proto.RegisterType((*Deposit)(nil), "injective.exchange.v1beta1.Deposit")
	proto.RegisterType((*SubaccountTradeNonce)(nil), "injective.exchange.v1beta1.SubaccountTradeNonce")
	proto.RegisterType((*OrderInfo)(nil), "injective.exchange.v1beta1.OrderInfo")
	proto.RegisterType((*SpotOrder)(nil), "injective.exchange.v1beta1.SpotOrder")
	proto.RegisterType((*SpotLimitOrder)(nil), "injective.exchange.v1beta1.SpotLimitOrder")
	proto.RegisterType((*SpotMarketOrder)(nil), "injective.exchange.v1beta1.SpotMarketOrder")
	proto.RegisterType((*DerivativeOrder)(nil), "injective.exchange.v1beta1.DerivativeOrder")
	proto.RegisterType((*SubaccountOrderbookMetadata)(nil), "injective.exchange.v1beta1.SubaccountOrderbookMetadata")
	proto.RegisterType((*SubaccountOrder)(nil), "injective.exchange.v1beta1.SubaccountOrder")
	proto.RegisterType((*SubaccountOrderData)(nil), "injective.exchange.v1beta1.SubaccountOrderData")
	proto.RegisterType((*DerivativeLimitOrder)(nil), "injective.exchange.v1beta1.DerivativeLimitOrder")
	proto.RegisterType((*DerivativeMarketOrder)(nil), "injective.exchange.v1beta1.DerivativeMarketOrder")
	proto.RegisterType((*Position)(nil), "injective.exchange.v1beta1.Position")
	proto.RegisterType((*MarketOrderIndicator)(nil), "injective.exchange.v1beta1.MarketOrderIndicator")
	proto.RegisterType((*TradeLog)(nil), "injective.exchange.v1beta1.TradeLog")
	proto.RegisterType((*PositionDelta)(nil), "injective.exchange.v1beta1.PositionDelta")
	proto.RegisterType((*DerivativeTradeLog)(nil), "injective.exchange.v1beta1.DerivativeTradeLog")
	proto.RegisterType((*SubaccountPosition)(nil), "injective.exchange.v1beta1.SubaccountPosition")
	proto.RegisterType((*SubaccountDeposit)(nil), "injective.exchange.v1beta1.SubaccountDeposit")
	proto.RegisterType((*DepositUpdate)(nil), "injective.exchange.v1beta1.DepositUpdate")
	proto.RegisterType((*PointsMultiplier)(nil), "injective.exchange.v1beta1.PointsMultiplier")
	proto.RegisterType((*TradingRewardCampaignBoostInfo)(nil), "injective.exchange.v1beta1.TradingRewardCampaignBoostInfo")
	proto.RegisterType((*CampaignRewardPool)(nil), "injective.exchange.v1beta1.CampaignRewardPool")
	proto.RegisterType((*TradingRewardCampaignInfo)(nil), "injective.exchange.v1beta1.TradingRewardCampaignInfo")
	proto.RegisterType((*FeeDiscountTierInfo)(nil), "injective.exchange.v1beta1.FeeDiscountTierInfo")
	proto.RegisterType((*FeeDiscountSchedule)(nil), "injective.exchange.v1beta1.FeeDiscountSchedule")
	proto.RegisterType((*FeeDiscountTierTTL)(nil), "injective.exchange.v1beta1.FeeDiscountTierTTL")
	proto.RegisterType((*VolumeRecord)(nil), "injective.exchange.v1beta1.VolumeRecord")
	proto.RegisterType((*AccountRewards)(nil), "injective.exchange.v1beta1.AccountRewards")
	proto.RegisterType((*TradeRecords)(nil), "injective.exchange.v1beta1.TradeRecords")
	proto.RegisterType((*SubaccountIDs)(nil), "injective.exchange.v1beta1.SubaccountIDs")
	proto.RegisterType((*TradeRecord)(nil), "injective.exchange.v1beta1.TradeRecord")
	proto.RegisterType((*Level)(nil), "injective.exchange.v1beta1.Level")
	proto.RegisterType((*AggregateSubaccountVolumeRecord)(nil), "injective.exchange.v1beta1.AggregateSubaccountVolumeRecord")
	proto.RegisterType((*AggregateAccountVolumeRecord)(nil), "injective.exchange.v1beta1.AggregateAccountVolumeRecord")
	proto.RegisterType((*MarketVolume)(nil), "injective.exchange.v1beta1.MarketVolume")
	proto.RegisterType((*DenomDecimals)(nil), "injective.exchange.v1beta1.DenomDecimals")
	proto.RegisterType((*GrantAuthorization)(nil), "injective.exchange.v1beta1.GrantAuthorization")
	proto.RegisterType((*ActiveGrant)(nil), "injective.exchange.v1beta1.ActiveGrant")
	proto.RegisterType((*EffectiveGrant)(nil), "injective.exchange.v1beta1.EffectiveGrant")
}

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

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

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

	that1, ok := that.(*Params)
	if !ok {
		that2, ok := that.(Params)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.SpotMarketInstantListingFee.Equal(&that1.SpotMarketInstantListingFee) {
		return false
	}
	if !this.DerivativeMarketInstantListingFee.Equal(&that1.DerivativeMarketInstantListingFee) {
		return false
	}
	if !this.DefaultSpotMakerFeeRate.Equal(that1.DefaultSpotMakerFeeRate) {
		return false
	}
	if !this.DefaultSpotTakerFeeRate.Equal(that1.DefaultSpotTakerFeeRate) {
		return false
	}
	if !this.DefaultDerivativeMakerFeeRate.Equal(that1.DefaultDerivativeMakerFeeRate) {
		return false
	}
	if !this.DefaultDerivativeTakerFeeRate.Equal(that1.DefaultDerivativeTakerFeeRate) {
		return false
	}
	if !this.DefaultInitialMarginRatio.Equal(that1.DefaultInitialMarginRatio) {
		return false
	}
	if !this.DefaultMaintenanceMarginRatio.Equal(that1.DefaultMaintenanceMarginRatio) {
		return false
	}
	if this.DefaultFundingInterval != that1.DefaultFundingInterval {
		return false
	}
	if this.FundingMultiple != that1.FundingMultiple {
		return false
	}
	if !this.RelayerFeeShareRate.Equal(that1.RelayerFeeShareRate) {
		return false
	}
	if !this.DefaultHourlyFundingRateCap.Equal(that1.DefaultHourlyFundingRateCap) {
		return false
	}
	if !this.DefaultHourlyInterestRate.Equal(that1.DefaultHourlyInterestRate) {
		return false
	}
	if this.MaxDerivativeOrderSideCount != that1.MaxDerivativeOrderSideCount {
		return false
	}
	if !this.InjRewardStakedRequirementThreshold.Equal(that1.InjRewardStakedRequirementThreshold) {
		return false
	}
	if this.TradingRewardsVestingDuration != that1.TradingRewardsVestingDuration {
		return false
	}
	if !this.LiquidatorRewardShareRate.Equal(that1.LiquidatorRewardShareRate) {
		return false
	}
	if !this.BinaryOptionsMarketInstantListingFee.Equal(&that1.BinaryOptionsMarketInstantListingFee) {
		return false
	}
	if this.AtomicMarketOrderAccessLevel != that1.AtomicMarketOrderAccessLevel {
		return false
	}
	if !this.SpotAtomicMarketOrderFeeMultiplier.Equal(that1.SpotAtomicMarketOrderFeeMultiplier) {
		return false
	}
	if !this.DerivativeAtomicMarketOrderFeeMultiplier.Equal(that1.DerivativeAtomicMarketOrderFeeMultiplier) {
		return false
	}
	if !this.BinaryOptionsAtomicMarketOrderFeeMultiplier.Equal(that1.BinaryOptionsAtomicMarketOrderFeeMultiplier) {
		return false
	}
	if !this.MinimalProtocolFeeRate.Equal(that1.MinimalProtocolFeeRate) {
		return false
	}
	if this.IsInstantDerivativeMarketLaunchEnabled != that1.IsInstantDerivativeMarketLaunchEnabled {
		return false
	}
	if this.PostOnlyModeHeightThreshold != that1.PostOnlyModeHeightThreshold {
		return false
	}
	if this.MarginDecreasePriceTimestampThresholdSeconds != that1.MarginDecreasePriceTimestampThresholdSeconds {
		return false
	}
	if len(this.ExchangeAdmins) != len(that1.ExchangeAdmins) {
		return false
	}
	for i := range this.ExchangeAdmins {
		if this.ExchangeAdmins[i] != that1.ExchangeAdmins[i] {
			return false
		}
	}
	if !this.InjAuctionMaxCap.Equal(that1.InjAuctionMaxCap) {
		return false
	}
	return true
}
func (m *Params) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Params) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.InjAuctionMaxCap.Size()
		i -= size
		if _, err := m.InjAuctionMaxCap.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xe2
	if len(m.ExchangeAdmins) > 0 {
		for iNdEx := len(m.ExchangeAdmins) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ExchangeAdmins[iNdEx])
			copy(dAtA[i:], m.ExchangeAdmins[iNdEx])
			i = encodeVarintExchange(dAtA, i, uint64(len(m.ExchangeAdmins[iNdEx])))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xda
		}
	}
	if m.MarginDecreasePriceTimestampThresholdSeconds != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.MarginDecreasePriceTimestampThresholdSeconds))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd0
	}
	if m.PostOnlyModeHeightThreshold != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.PostOnlyModeHeightThreshold))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc8
	}
	if m.IsInstantDerivativeMarketLaunchEnabled {
		i--
		if m.IsInstantDerivativeMarketLaunchEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc0
	}
	{
		size := m.MinimalProtocolFeeRate.Size()
		i -= size
		if _, err := m.MinimalProtocolFeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xba
	{
		size := m.BinaryOptionsAtomicMarketOrderFeeMultiplier.Size()
		i -= size
		if _, err := m.BinaryOptionsAtomicMarketOrderFeeMultiplier.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xb2
	{
		size := m.DerivativeAtomicMarketOrderFeeMultiplier.Size()
		i -= size
		if _, err := m.DerivativeAtomicMarketOrderFeeMultiplier.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xaa
	{
		size := m.SpotAtomicMarketOrderFeeMultiplier.Size()
		i -= size
		if _, err := m.SpotAtomicMarketOrderFeeMultiplier.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xa2
	if m.AtomicMarketOrderAccessLevel != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.AtomicMarketOrderAccessLevel))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	{
		size, err := m.BinaryOptionsMarketInstantListingFee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x92
	{
		size := m.LiquidatorRewardShareRate.Size()
		i -= size
		if _, err := m.LiquidatorRewardShareRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x8a
	if m.TradingRewardsVestingDuration != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.TradingRewardsVestingDuration))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	{
		size := m.InjRewardStakedRequirementThreshold.Size()
		i -= size
		if _, err := m.InjRewardStakedRequirementThreshold.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x7a
	if m.MaxDerivativeOrderSideCount != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.MaxDerivativeOrderSideCount))
		i--
		dAtA[i] = 0x70
	}
	{
		size := m.DefaultHourlyInterestRate.Size()
		i -= size
		if _, err := m.DefaultHourlyInterestRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x6a
	{
		size := m.DefaultHourlyFundingRateCap.Size()
		i -= size
		if _, err := m.DefaultHourlyFundingRateCap.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x62
	{
		size := m.RelayerFeeShareRate.Size()
		i -= size
		if _, err := m.RelayerFeeShareRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x5a
	if m.FundingMultiple != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.FundingMultiple))
		i--
		dAtA[i] = 0x50
	}
	if m.DefaultFundingInterval != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.DefaultFundingInterval))
		i--
		dAtA[i] = 0x48
	}
	{
		size := m.DefaultMaintenanceMarginRatio.Size()
		i -= size
		if _, err := m.DefaultMaintenanceMarginRatio.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	{
		size := m.DefaultInitialMarginRatio.Size()
		i -= size
		if _, err := m.DefaultInitialMarginRatio.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size := m.DefaultDerivativeTakerFeeRate.Size()
		i -= size
		if _, err := m.DefaultDerivativeTakerFeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size := m.DefaultDerivativeMakerFeeRate.Size()
		i -= size
		if _, err := m.DefaultDerivativeMakerFeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.DefaultSpotTakerFeeRate.Size()
		i -= size
		if _, err := m.DefaultSpotTakerFeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.DefaultSpotMakerFeeRate.Size()
		i -= size
		if _, err := m.DefaultSpotMakerFeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.DerivativeMarketInstantListingFee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.SpotMarketInstantListingFee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

func (m *DerivativeMarket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AdminPermissions != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.AdminPermissions))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	if len(m.Admin) > 0 {
		i -= len(m.Admin)
		copy(dAtA[i:], m.Admin)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.Admin)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	{
		size := m.MinNotional.Size()
		i -= size
		if _, err := m.MinNotional.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x8a
	{
		size := m.MinQuantityTickSize.Size()
		i -= size
		if _, err := m.MinQuantityTickSize.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x82
	{
		size := m.MinPriceTickSize.Size()
		i -= size
		if _, err := m.MinPriceTickSize.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x7a
	if m.Status != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x70
	}
	if m.IsPerpetual {
		i--
		if m.IsPerpetual {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	{
		size := m.RelayerFeeShareRate.Size()
		i -= size
		if _, err := m.RelayerFeeShareRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x62
	{
		size := m.TakerFeeRate.Size()
		i -= size
		if _, err := m.TakerFeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x5a
	{
		size := m.MakerFeeRate.Size()
		i -= size
		if _, err := m.MakerFeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x52
	{
		size := m.MaintenanceMarginRatio.Size()
		i -= size
		if _, err := m.MaintenanceMarginRatio.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	{
		size := m.InitialMarginRatio.Size()
		i -= size
		if _, err := m.InitialMarginRatio.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	if len(m.MarketId) > 0 {
		i -= len(m.MarketId)
		copy(dAtA[i:], m.MarketId)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.MarketId)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.QuoteDenom) > 0 {
		i -= len(m.QuoteDenom)
		copy(dAtA[i:], m.QuoteDenom)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.QuoteDenom)))
		i--
		dAtA[i] = 0x32
	}
	if m.OracleScaleFactor != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.OracleScaleFactor))
		i--
		dAtA[i] = 0x28
	}
	if m.OracleType != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.OracleType))
		i--
		dAtA[i] = 0x20
	}
	if len(m.OracleQuote) > 0 {
		i -= len(m.OracleQuote)
		copy(dAtA[i:], m.OracleQuote)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.OracleQuote)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.OracleBase) > 0 {
		i -= len(m.OracleBase)
		copy(dAtA[i:], m.OracleBase)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.OracleBase)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Ticker) > 0 {
		i -= len(m.Ticker)
		copy(dAtA[i:], m.Ticker)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.Ticker)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *BinaryOptionsMarket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AdminPermissions != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.AdminPermissions))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	{
		size := m.MinNotional.Size()
		i -= size
		if _, err := m.MinNotional.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x92
	if m.SettlementPrice != nil {
		{
			size := m.SettlementPrice.Size()
			i -= size
			if _, err := m.SettlementPrice.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintExchange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	{
		size := m.MinQuantityTickSize.Size()
		i -= size
		if _, err := m.MinQuantityTickSize.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x82
	{
		size := m.MinPriceTickSize.Size()
		i -= size
		if _, err := m.MinPriceTickSize.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x7a
	if m.Status != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x70
	}
	{
		size := m.RelayerFeeShareRate.Size()
		i -= size
		if _, err := m.RelayerFeeShareRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x6a
	{
		size := m.TakerFeeRate.Size()
		i -= size
		if _, err := m.TakerFeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x62
	{
		size := m.MakerFeeRate.Size()
		i -= size
		if _, err := m.MakerFeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x5a
	if len(m.MarketId) > 0 {
		i -= len(m.MarketId)
		copy(dAtA[i:], m.MarketId)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.MarketId)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.QuoteDenom) > 0 {
		i -= len(m.QuoteDenom)
		copy(dAtA[i:], m.QuoteDenom)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.QuoteDenom)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.Admin) > 0 {
		i -= len(m.Admin)
		copy(dAtA[i:], m.Admin)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.Admin)))
		i--
		dAtA[i] = 0x42
	}
	if m.SettlementTimestamp != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.SettlementTimestamp))
		i--
		dAtA[i] = 0x38
	}
	if m.ExpirationTimestamp != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.ExpirationTimestamp))
		i--
		dAtA[i] = 0x30
	}
	if m.OracleScaleFactor != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.OracleScaleFactor))
		i--
		dAtA[i] = 0x28
	}
	if m.OracleType != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.OracleType))
		i--
		dAtA[i] = 0x20
	}
	if len(m.OracleProvider) > 0 {
		i -= len(m.OracleProvider)
		copy(dAtA[i:], m.OracleProvider)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.OracleProvider)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.OracleSymbol) > 0 {
		i -= len(m.OracleSymbol)
		copy(dAtA[i:], m.OracleSymbol)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.OracleSymbol)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Ticker) > 0 {
		i -= len(m.Ticker)
		copy(dAtA[i:], m.Ticker)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.Ticker)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ExpiryFuturesMarketInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.SettlementPrice.Size()
		i -= size
		if _, err := m.SettlementPrice.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.ExpirationTwapStartPriceCumulative.Size()
		i -= size
		if _, err := m.ExpirationTwapStartPriceCumulative.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.TwapStartTimestamp != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.TwapStartTimestamp))
		i--
		dAtA[i] = 0x18
	}
	if m.ExpirationTimestamp != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.ExpirationTimestamp))
		i--
		dAtA[i] = 0x10
	}
	if len(m.MarketId) > 0 {
		i -= len(m.MarketId)
		copy(dAtA[i:], m.MarketId)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.MarketId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PerpetualMarketInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FundingInterval != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.FundingInterval))
		i--
		dAtA[i] = 0x28
	}
	if m.NextFundingTimestamp != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.NextFundingTimestamp))
		i--
		dAtA[i] = 0x20
	}
	{
		size := m.HourlyInterestRate.Size()
		i -= size
		if _, err := m.HourlyInterestRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.HourlyFundingRateCap.Size()
		i -= size
		if _, err := m.HourlyFundingRateCap.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.MarketId) > 0 {
		i -= len(m.MarketId)
		copy(dAtA[i:], m.MarketId)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.MarketId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PerpetualMarketFunding) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LastTimestamp != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.LastTimestamp))
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.CumulativePrice.Size()
		i -= size
		if _, err := m.CumulativePrice.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.CumulativeFunding.Size()
		i -= size
		if _, err := m.CumulativeFunding.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

func (m *NextFundingTimestamp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NextTimestamp != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.NextTimestamp))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *MidPriceAndTOB) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BestSellPrice != nil {
		{
			size := m.BestSellPrice.Size()
			i -= size
			if _, err := m.BestSellPrice.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintExchange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.BestBuyPrice != nil {
		{
			size := m.BestBuyPrice.Size()
			i -= size
			if _, err := m.BestBuyPrice.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintExchange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.MidPrice != nil {
		{
			size := m.MidPrice.Size()
			i -= size
			if _, err := m.MidPrice.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintExchange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SpotMarket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AdminPermissions != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.AdminPermissions))
		i--
		dAtA[i] = 0x68
	}
	if len(m.Admin) > 0 {
		i -= len(m.Admin)
		copy(dAtA[i:], m.Admin)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.Admin)))
		i--
		dAtA[i] = 0x62
	}
	{
		size := m.MinNotional.Size()
		i -= size
		if _, err := m.MinNotional.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x5a
	{
		size := m.MinQuantityTickSize.Size()
		i -= size
		if _, err := m.MinQuantityTickSize.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x52
	{
		size := m.MinPriceTickSize.Size()
		i -= size
		if _, err := m.MinPriceTickSize.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	if m.Status != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x40
	}
	if len(m.MarketId) > 0 {
		i -= len(m.MarketId)
		copy(dAtA[i:], m.MarketId)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.MarketId)))
		i--
		dAtA[i] = 0x3a
	}
	{
		size := m.RelayerFeeShareRate.Size()
		i -= size
		if _, err := m.RelayerFeeShareRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size := m.TakerFeeRate.Size()
		i -= size
		if _, err := m.TakerFeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.MakerFeeRate.Size()
		i -= size
		if _, err := m.MakerFeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.QuoteDenom) > 0 {
		i -= len(m.QuoteDenom)
		copy(dAtA[i:], m.QuoteDenom)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.QuoteDenom)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BaseDenom) > 0 {
		i -= len(m.BaseDenom)
		copy(dAtA[i:], m.BaseDenom)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.BaseDenom)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Ticker) > 0 {
		i -= len(m.Ticker)
		copy(dAtA[i:], m.Ticker)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.Ticker)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Deposit) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Deposit) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Deposit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.TotalBalance.Size()
		i -= size
		if _, err := m.TotalBalance.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.AvailableBalance.Size()
		i -= size
		if _, err := m.AvailableBalance.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *SubaccountTradeNonce) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Nonce != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *OrderInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Cid) > 0 {
		i -= len(m.Cid)
		copy(dAtA[i:], m.Cid)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.Cid)))
		i--
		dAtA[i] = 0x2a
	}
	{
		size := m.Quantity.Size()
		i -= size
		if _, err := m.Quantity.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.Price.Size()
		i -= size
		if _, err := m.Price.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.FeeRecipient) > 0 {
		i -= len(m.FeeRecipient)
		copy(dAtA[i:], m.FeeRecipient)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.FeeRecipient)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SubaccountId) > 0 {
		i -= len(m.SubaccountId)
		copy(dAtA[i:], m.SubaccountId)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.SubaccountId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SpotOrder) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TriggerPrice != nil {
		{
			size := m.TriggerPrice.Size()
			i -= size
			if _, err := m.TriggerPrice.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintExchange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.OrderType != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.OrderType))
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.OrderInfo.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.MarketId) > 0 {
		i -= len(m.MarketId)
		copy(dAtA[i:], m.MarketId)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.MarketId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SpotLimitOrder) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OrderHash) > 0 {
		i -= len(m.OrderHash)
		copy(dAtA[i:], m.OrderHash)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.OrderHash)))
		i--
		dAtA[i] = 0x2a
	}
	if m.TriggerPrice != nil {
		{
			size := m.TriggerPrice.Size()
			i -= size
			if _, err := m.TriggerPrice.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintExchange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	{
		size := m.Fillable.Size()
		i -= size
		if _, err := m.Fillable.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.OrderType != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.OrderType))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.OrderInfo.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *SpotMarketOrder) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TriggerPrice != nil {
		{
			size := m.TriggerPrice.Size()
			i -= size
			if _, err := m.TriggerPrice.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintExchange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.OrderType != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.OrderType))
		i--
		dAtA[i] = 0x20
	}
	if len(m.OrderHash) > 0 {
		i -= len(m.OrderHash)
		copy(dAtA[i:], m.OrderHash)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.OrderHash)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.BalanceHold.Size()
		i -= size
		if _, err := m.BalanceHold.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.OrderInfo.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *DerivativeOrder) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TriggerPrice != nil {
		{
			size := m.TriggerPrice.Size()
			i -= size
			if _, err := m.TriggerPrice.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintExchange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	{
		size := m.Margin.Size()
		i -= size
		if _, err := m.Margin.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.OrderType != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.OrderType))
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.OrderInfo.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.MarketId) > 0 {
		i -= len(m.MarketId)
		copy(dAtA[i:], m.MarketId)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.MarketId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SubaccountOrderbookMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ReduceOnlyConditionalOrderCount != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.ReduceOnlyConditionalOrderCount))
		i--
		dAtA[i] = 0x30
	}
	if m.VanillaConditionalOrderCount != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.VanillaConditionalOrderCount))
		i--
		dAtA[i] = 0x28
	}
	{
		size := m.AggregateVanillaQuantity.Size()
		i -= size
		if _, err := m.AggregateVanillaQuantity.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.AggregateReduceOnlyQuantity.Size()
		i -= size
		if _, err := m.AggregateReduceOnlyQuantity.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.ReduceOnlyLimitOrderCount != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.ReduceOnlyLimitOrderCount))
		i--
		dAtA[i] = 0x10
	}
	if m.VanillaLimitOrderCount != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.VanillaLimitOrderCount))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SubaccountOrder) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Cid) > 0 {
		i -= len(m.Cid)
		copy(dAtA[i:], m.Cid)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.Cid)))
		i--
		dAtA[i] = 0x22
	}
	if m.IsReduceOnly {
		i--
		if m.IsReduceOnly {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.Quantity.Size()
		i -= size
		if _, err := m.Quantity.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.Price.Size()
		i -= size
		if _, err := m.Price.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

func (m *DerivativeLimitOrder) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OrderHash) > 0 {
		i -= len(m.OrderHash)
		copy(dAtA[i:], m.OrderHash)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.OrderHash)))
		i--
		dAtA[i] = 0x32
	}
	if m.TriggerPrice != nil {
		{
			size := m.TriggerPrice.Size()
			i -= size
			if _, err := m.TriggerPrice.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintExchange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	{
		size := m.Fillable.Size()
		i -= size
		if _, err := m.Fillable.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.Margin.Size()
		i -= size
		if _, err := m.Margin.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.OrderType != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.OrderType))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.OrderInfo.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *DerivativeMarketOrder) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OrderHash) > 0 {
		i -= len(m.OrderHash)
		copy(dAtA[i:], m.OrderHash)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.OrderHash)))
		i--
		dAtA[i] = 0x32
	}
	if m.TriggerPrice != nil {
		{
			size := m.TriggerPrice.Size()
			i -= size
			if _, err := m.TriggerPrice.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintExchange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	{
		size := m.MarginHold.Size()
		i -= size
		if _, err := m.MarginHold.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.Margin.Size()
		i -= size
		if _, err := m.Margin.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.OrderType != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.OrderType))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.OrderInfo.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *Position) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.CumulativeFundingEntry.Size()
		i -= size
		if _, err := m.CumulativeFundingEntry.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.Margin.Size()
		i -= size
		if _, err := m.Margin.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.EntryPrice.Size()
		i -= size
		if _, err := m.EntryPrice.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.Quantity.Size()
		i -= size
		if _, err := m.Quantity.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.IsLong {
		i--
		if m.IsLong {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *MarketOrderIndicator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsBuy {
		i--
		if m.IsBuy {
			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 = encodeVarintExchange(dAtA, i, uint64(len(m.MarketId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TradeLog) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Cid) > 0 {
		i -= len(m.Cid)
		copy(dAtA[i:], m.Cid)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.Cid)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.FeeRecipientAddress) > 0 {
		i -= len(m.FeeRecipientAddress)
		copy(dAtA[i:], m.FeeRecipientAddress)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.FeeRecipientAddress)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.OrderHash) > 0 {
		i -= len(m.OrderHash)
		copy(dAtA[i:], m.OrderHash)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.OrderHash)))
		i--
		dAtA[i] = 0x2a
	}
	{
		size := m.Fee.Size()
		i -= size
		if _, err := m.Fee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.SubaccountId) > 0 {
		i -= len(m.SubaccountId)
		copy(dAtA[i:], m.SubaccountId)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.SubaccountId)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.Price.Size()
		i -= size
		if _, err := m.Price.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.Quantity.Size()
		i -= size
		if _, err := m.Quantity.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *PositionDelta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.ExecutionPrice.Size()
		i -= size
		if _, err := m.ExecutionPrice.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.ExecutionMargin.Size()
		i -= size
		if _, err := m.ExecutionMargin.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.ExecutionQuantity.Size()
		i -= size
		if _, err := m.ExecutionQuantity.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.IsLong {
		i--
		if m.IsLong {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *DerivativeTradeLog) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Pnl.Size()
		i -= size
		if _, err := m.Pnl.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	if len(m.Cid) > 0 {
		i -= len(m.Cid)
		copy(dAtA[i:], m.Cid)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.Cid)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.FeeRecipientAddress) > 0 {
		i -= len(m.FeeRecipientAddress)
		copy(dAtA[i:], m.FeeRecipientAddress)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.FeeRecipientAddress)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.OrderHash) > 0 {
		i -= len(m.OrderHash)
		copy(dAtA[i:], m.OrderHash)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.OrderHash)))
		i--
		dAtA[i] = 0x2a
	}
	{
		size := m.Fee.Size()
		i -= size
		if _, err := m.Fee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.Payout.Size()
		i -= size
		if _, err := m.Payout.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.PositionDelta != nil {
		{
			size, err := m.PositionDelta.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExchange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.SubaccountId) > 0 {
		i -= len(m.SubaccountId)
		copy(dAtA[i:], m.SubaccountId)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.SubaccountId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *PointsMultiplier) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.TakerPointsMultiplier.Size()
		i -= size
		if _, err := m.TakerPointsMultiplier.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.MakerPointsMultiplier.Size()
		i -= size
		if _, err := m.MakerPointsMultiplier.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *TradingRewardCampaignBoostInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DerivativeMarketMultipliers) > 0 {
		for iNdEx := len(m.DerivativeMarketMultipliers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DerivativeMarketMultipliers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintExchange(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.BoostedDerivativeMarketIds) > 0 {
		for iNdEx := len(m.BoostedDerivativeMarketIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BoostedDerivativeMarketIds[iNdEx])
			copy(dAtA[i:], m.BoostedDerivativeMarketIds[iNdEx])
			i = encodeVarintExchange(dAtA, i, uint64(len(m.BoostedDerivativeMarketIds[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.SpotMarketMultipliers) > 0 {
		for iNdEx := len(m.SpotMarketMultipliers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SpotMarketMultipliers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintExchange(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.BoostedSpotMarketIds) > 0 {
		for iNdEx := len(m.BoostedSpotMarketIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BoostedSpotMarketIds[iNdEx])
			copy(dAtA[i:], m.BoostedSpotMarketIds[iNdEx])
			i = encodeVarintExchange(dAtA, i, uint64(len(m.BoostedSpotMarketIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *TradingRewardCampaignInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DisqualifiedMarketIds) > 0 {
		for iNdEx := len(m.DisqualifiedMarketIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.DisqualifiedMarketIds[iNdEx])
			copy(dAtA[i:], m.DisqualifiedMarketIds[iNdEx])
			i = encodeVarintExchange(dAtA, i, uint64(len(m.DisqualifiedMarketIds[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.TradingRewardBoostInfo != nil {
		{
			size, err := m.TradingRewardBoostInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExchange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.QuoteDenoms) > 0 {
		for iNdEx := len(m.QuoteDenoms) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.QuoteDenoms[iNdEx])
			copy(dAtA[i:], m.QuoteDenoms[iNdEx])
			i = encodeVarintExchange(dAtA, i, uint64(len(m.QuoteDenoms[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.CampaignDurationSeconds != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.CampaignDurationSeconds))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *FeeDiscountTierInfo) 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 = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.StakedAmount.Size()
		i -= size
		if _, err := m.StakedAmount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.TakerDiscountRate.Size()
		i -= size
		if _, err := m.TakerDiscountRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.MakerDiscountRate.Size()
		i -= size
		if _, err := m.MakerDiscountRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *FeeDiscountSchedule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DisqualifiedMarketIds) > 0 {
		for iNdEx := len(m.DisqualifiedMarketIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.DisqualifiedMarketIds[iNdEx])
			copy(dAtA[i:], m.DisqualifiedMarketIds[iNdEx])
			i = encodeVarintExchange(dAtA, i, uint64(len(m.DisqualifiedMarketIds[iNdEx])))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.TierInfos) > 0 {
		for iNdEx := len(m.TierInfos) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TierInfos[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintExchange(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.QuoteDenoms) > 0 {
		for iNdEx := len(m.QuoteDenoms) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.QuoteDenoms[iNdEx])
			copy(dAtA[i:], m.QuoteDenoms[iNdEx])
			i = encodeVarintExchange(dAtA, i, uint64(len(m.QuoteDenoms[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.BucketDuration != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.BucketDuration))
		i--
		dAtA[i] = 0x10
	}
	if m.BucketCount != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.BucketCount))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *FeeDiscountTierTTL) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TtlTimestamp != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.TtlTimestamp))
		i--
		dAtA[i] = 0x10
	}
	if m.Tier != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.Tier))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *VolumeRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.TakerVolume.Size()
		i -= size
		if _, err := m.TakerVolume.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.MakerVolume.Size()
		i -= size
		if _, err := m.MakerVolume.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *SubaccountIDs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubaccountIds) > 0 {
		for iNdEx := len(m.SubaccountIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubaccountIds[iNdEx])
			copy(dAtA[i:], m.SubaccountIds[iNdEx])
			i = encodeVarintExchange(dAtA, i, uint64(len(m.SubaccountIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *TradeRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Quantity.Size()
		i -= size
		if _, err := m.Quantity.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.Price.Size()
		i -= size
		if _, err := m.Price.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Timestamp != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Level) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Q.Size()
		i -= size
		if _, err := m.Q.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.P.Size()
		i -= size
		if _, err := m.P.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *AggregateSubaccountVolumeRecord) 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 = encodeVarintExchange(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.SubaccountId) > 0 {
		i -= len(m.SubaccountId)
		copy(dAtA[i:], m.SubaccountId)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.SubaccountId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AggregateAccountVolumeRecord) 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 = encodeVarintExchange(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Account) > 0 {
		i -= len(m.Account)
		copy(dAtA[i:], m.Account)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.Account)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *DenomDecimals) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Decimals != 0 {
		i = encodeVarintExchange(dAtA, i, uint64(m.Decimals))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.Denom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *EffectiveGrant) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsValid {
		i--
		if m.IsValid {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.NetGrantedStake.Size()
		i -= size
		if _, err := m.NetGrantedStake.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExchange(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Granter) > 0 {
		i -= len(m.Granter)
		copy(dAtA[i:], m.Granter)
		i = encodeVarintExchange(dAtA, i, uint64(len(m.Granter)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintExchange(dAtA []byte, offset int, v uint64) int {
	offset -= sovExchange(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Params) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.SpotMarketInstantListingFee.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.DerivativeMarketInstantListingFee.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.DefaultSpotMakerFeeRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.DefaultSpotTakerFeeRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.DefaultDerivativeMakerFeeRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.DefaultDerivativeTakerFeeRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.DefaultInitialMarginRatio.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.DefaultMaintenanceMarginRatio.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.DefaultFundingInterval != 0 {
		n += 1 + sovExchange(uint64(m.DefaultFundingInterval))
	}
	if m.FundingMultiple != 0 {
		n += 1 + sovExchange(uint64(m.FundingMultiple))
	}
	l = m.RelayerFeeShareRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.DefaultHourlyFundingRateCap.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.DefaultHourlyInterestRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.MaxDerivativeOrderSideCount != 0 {
		n += 1 + sovExchange(uint64(m.MaxDerivativeOrderSideCount))
	}
	l = m.InjRewardStakedRequirementThreshold.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.TradingRewardsVestingDuration != 0 {
		n += 2 + sovExchange(uint64(m.TradingRewardsVestingDuration))
	}
	l = m.LiquidatorRewardShareRate.Size()
	n += 2 + l + sovExchange(uint64(l))
	l = m.BinaryOptionsMarketInstantListingFee.Size()
	n += 2 + l + sovExchange(uint64(l))
	if m.AtomicMarketOrderAccessLevel != 0 {
		n += 2 + sovExchange(uint64(m.AtomicMarketOrderAccessLevel))
	}
	l = m.SpotAtomicMarketOrderFeeMultiplier.Size()
	n += 2 + l + sovExchange(uint64(l))
	l = m.DerivativeAtomicMarketOrderFeeMultiplier.Size()
	n += 2 + l + sovExchange(uint64(l))
	l = m.BinaryOptionsAtomicMarketOrderFeeMultiplier.Size()
	n += 2 + l + sovExchange(uint64(l))
	l = m.MinimalProtocolFeeRate.Size()
	n += 2 + l + sovExchange(uint64(l))
	if m.IsInstantDerivativeMarketLaunchEnabled {
		n += 3
	}
	if m.PostOnlyModeHeightThreshold != 0 {
		n += 2 + sovExchange(uint64(m.PostOnlyModeHeightThreshold))
	}
	if m.MarginDecreasePriceTimestampThresholdSeconds != 0 {
		n += 2 + sovExchange(uint64(m.MarginDecreasePriceTimestampThresholdSeconds))
	}
	if len(m.ExchangeAdmins) > 0 {
		for _, s := range m.ExchangeAdmins {
			l = len(s)
			n += 2 + l + sovExchange(uint64(l))
		}
	}
	l = m.InjAuctionMaxCap.Size()
	n += 2 + l + sovExchange(uint64(l))
	return n
}

func (m *MarketFeeMultiplier) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.FeeMultiplier.Size()
	n += 1 + l + sovExchange(uint64(l))
	return n
}

func (m *DerivativeMarket) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Ticker)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.OracleBase)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.OracleQuote)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	if m.OracleType != 0 {
		n += 1 + sovExchange(uint64(m.OracleType))
	}
	if m.OracleScaleFactor != 0 {
		n += 1 + sovExchange(uint64(m.OracleScaleFactor))
	}
	l = len(m.QuoteDenom)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.InitialMarginRatio.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.MaintenanceMarginRatio.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.MakerFeeRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.TakerFeeRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.RelayerFeeShareRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.IsPerpetual {
		n += 2
	}
	if m.Status != 0 {
		n += 1 + sovExchange(uint64(m.Status))
	}
	l = m.MinPriceTickSize.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.MinQuantityTickSize.Size()
	n += 2 + l + sovExchange(uint64(l))
	l = m.MinNotional.Size()
	n += 2 + l + sovExchange(uint64(l))
	l = len(m.Admin)
	if l > 0 {
		n += 2 + l + sovExchange(uint64(l))
	}
	if m.AdminPermissions != 0 {
		n += 2 + sovExchange(uint64(m.AdminPermissions))
	}
	return n
}

func (m *BinaryOptionsMarket) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Ticker)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.OracleSymbol)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.OracleProvider)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	if m.OracleType != 0 {
		n += 1 + sovExchange(uint64(m.OracleType))
	}
	if m.OracleScaleFactor != 0 {
		n += 1 + sovExchange(uint64(m.OracleScaleFactor))
	}
	if m.ExpirationTimestamp != 0 {
		n += 1 + sovExchange(uint64(m.ExpirationTimestamp))
	}
	if m.SettlementTimestamp != 0 {
		n += 1 + sovExchange(uint64(m.SettlementTimestamp))
	}
	l = len(m.Admin)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.QuoteDenom)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.MakerFeeRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.TakerFeeRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.RelayerFeeShareRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.Status != 0 {
		n += 1 + sovExchange(uint64(m.Status))
	}
	l = m.MinPriceTickSize.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.MinQuantityTickSize.Size()
	n += 2 + l + sovExchange(uint64(l))
	if m.SettlementPrice != nil {
		l = m.SettlementPrice.Size()
		n += 2 + l + sovExchange(uint64(l))
	}
	l = m.MinNotional.Size()
	n += 2 + l + sovExchange(uint64(l))
	if m.AdminPermissions != 0 {
		n += 2 + sovExchange(uint64(m.AdminPermissions))
	}
	return n
}

func (m *ExpiryFuturesMarketInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	if m.ExpirationTimestamp != 0 {
		n += 1 + sovExchange(uint64(m.ExpirationTimestamp))
	}
	if m.TwapStartTimestamp != 0 {
		n += 1 + sovExchange(uint64(m.TwapStartTimestamp))
	}
	l = m.ExpirationTwapStartPriceCumulative.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.SettlementPrice.Size()
	n += 1 + l + sovExchange(uint64(l))
	return n
}

func (m *PerpetualMarketInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.HourlyFundingRateCap.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.HourlyInterestRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.NextFundingTimestamp != 0 {
		n += 1 + sovExchange(uint64(m.NextFundingTimestamp))
	}
	if m.FundingInterval != 0 {
		n += 1 + sovExchange(uint64(m.FundingInterval))
	}
	return n
}

func (m *PerpetualMarketFunding) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.CumulativeFunding.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.CumulativePrice.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.LastTimestamp != 0 {
		n += 1 + sovExchange(uint64(m.LastTimestamp))
	}
	return n
}

func (m *DerivativeMarketSettlementInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.SettlementPrice.Size()
	n += 1 + l + sovExchange(uint64(l))
	return n
}

func (m *NextFundingTimestamp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NextTimestamp != 0 {
		n += 1 + sovExchange(uint64(m.NextTimestamp))
	}
	return n
}

func (m *MidPriceAndTOB) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MidPrice != nil {
		l = m.MidPrice.Size()
		n += 1 + l + sovExchange(uint64(l))
	}
	if m.BestBuyPrice != nil {
		l = m.BestBuyPrice.Size()
		n += 1 + l + sovExchange(uint64(l))
	}
	if m.BestSellPrice != nil {
		l = m.BestSellPrice.Size()
		n += 1 + l + sovExchange(uint64(l))
	}
	return n
}

func (m *SpotMarket) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Ticker)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.BaseDenom)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.QuoteDenom)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.MakerFeeRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.TakerFeeRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.RelayerFeeShareRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovExchange(uint64(m.Status))
	}
	l = m.MinPriceTickSize.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.MinQuantityTickSize.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.MinNotional.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = len(m.Admin)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	if m.AdminPermissions != 0 {
		n += 1 + sovExchange(uint64(m.AdminPermissions))
	}
	return n
}

func (m *Deposit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.AvailableBalance.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.TotalBalance.Size()
	n += 1 + l + sovExchange(uint64(l))
	return n
}

func (m *SubaccountTradeNonce) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Nonce != 0 {
		n += 1 + sovExchange(uint64(m.Nonce))
	}
	return n
}

func (m *OrderInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SubaccountId)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.FeeRecipient)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.Price.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.Quantity.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = len(m.Cid)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	return n
}

func (m *SpotOrder) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.OrderInfo.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.OrderType != 0 {
		n += 1 + sovExchange(uint64(m.OrderType))
	}
	if m.TriggerPrice != nil {
		l = m.TriggerPrice.Size()
		n += 1 + l + sovExchange(uint64(l))
	}
	return n
}

func (m *SpotLimitOrder) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.OrderInfo.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.OrderType != 0 {
		n += 1 + sovExchange(uint64(m.OrderType))
	}
	l = m.Fillable.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.TriggerPrice != nil {
		l = m.TriggerPrice.Size()
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.OrderHash)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	return n
}

func (m *SpotMarketOrder) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.OrderInfo.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.BalanceHold.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = len(m.OrderHash)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	if m.OrderType != 0 {
		n += 1 + sovExchange(uint64(m.OrderType))
	}
	if m.TriggerPrice != nil {
		l = m.TriggerPrice.Size()
		n += 1 + l + sovExchange(uint64(l))
	}
	return n
}

func (m *DerivativeOrder) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.OrderInfo.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.OrderType != 0 {
		n += 1 + sovExchange(uint64(m.OrderType))
	}
	l = m.Margin.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.TriggerPrice != nil {
		l = m.TriggerPrice.Size()
		n += 1 + l + sovExchange(uint64(l))
	}
	return n
}

func (m *SubaccountOrderbookMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VanillaLimitOrderCount != 0 {
		n += 1 + sovExchange(uint64(m.VanillaLimitOrderCount))
	}
	if m.ReduceOnlyLimitOrderCount != 0 {
		n += 1 + sovExchange(uint64(m.ReduceOnlyLimitOrderCount))
	}
	l = m.AggregateReduceOnlyQuantity.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.AggregateVanillaQuantity.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.VanillaConditionalOrderCount != 0 {
		n += 1 + sovExchange(uint64(m.VanillaConditionalOrderCount))
	}
	if m.ReduceOnlyConditionalOrderCount != 0 {
		n += 1 + sovExchange(uint64(m.ReduceOnlyConditionalOrderCount))
	}
	return n
}

func (m *SubaccountOrder) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Price.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.Quantity.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.IsReduceOnly {
		n += 2
	}
	l = len(m.Cid)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	return n
}

func (m *SubaccountOrderData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Order != nil {
		l = m.Order.Size()
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.OrderHash)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	return n
}

func (m *DerivativeLimitOrder) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.OrderInfo.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.OrderType != 0 {
		n += 1 + sovExchange(uint64(m.OrderType))
	}
	l = m.Margin.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.Fillable.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.TriggerPrice != nil {
		l = m.TriggerPrice.Size()
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.OrderHash)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	return n
}

func (m *DerivativeMarketOrder) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.OrderInfo.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.OrderType != 0 {
		n += 1 + sovExchange(uint64(m.OrderType))
	}
	l = m.Margin.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.MarginHold.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.TriggerPrice != nil {
		l = m.TriggerPrice.Size()
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.OrderHash)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	return n
}

func (m *Position) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IsLong {
		n += 2
	}
	l = m.Quantity.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.EntryPrice.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.Margin.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.CumulativeFundingEntry.Size()
	n += 1 + l + sovExchange(uint64(l))
	return n
}

func (m *MarketOrderIndicator) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MarketId)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	if m.IsBuy {
		n += 2
	}
	return n
}

func (m *TradeLog) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Quantity.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.Price.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = len(m.SubaccountId)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.Fee.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = len(m.OrderHash)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.FeeRecipientAddress)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.Cid)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	return n
}

func (m *PositionDelta) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IsLong {
		n += 2
	}
	l = m.ExecutionQuantity.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.ExecutionMargin.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.ExecutionPrice.Size()
	n += 1 + l + sovExchange(uint64(l))
	return n
}

func (m *DerivativeTradeLog) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SubaccountId)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	if m.PositionDelta != nil {
		l = m.PositionDelta.Size()
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.Payout.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.Fee.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = len(m.OrderHash)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.FeeRecipientAddress)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = len(m.Cid)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.Pnl.Size()
	n += 1 + l + sovExchange(uint64(l))
	return n
}

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

func (m *SubaccountDeposit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SubaccountId)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	if m.Deposit != nil {
		l = m.Deposit.Size()
		n += 1 + l + sovExchange(uint64(l))
	}
	return n
}

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

func (m *PointsMultiplier) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MakerPointsMultiplier.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.TakerPointsMultiplier.Size()
	n += 1 + l + sovExchange(uint64(l))
	return n
}

func (m *TradingRewardCampaignBoostInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.BoostedSpotMarketIds) > 0 {
		for _, s := range m.BoostedSpotMarketIds {
			l = len(s)
			n += 1 + l + sovExchange(uint64(l))
		}
	}
	if len(m.SpotMarketMultipliers) > 0 {
		for _, e := range m.SpotMarketMultipliers {
			l = e.Size()
			n += 1 + l + sovExchange(uint64(l))
		}
	}
	if len(m.BoostedDerivativeMarketIds) > 0 {
		for _, s := range m.BoostedDerivativeMarketIds {
			l = len(s)
			n += 1 + l + sovExchange(uint64(l))
		}
	}
	if len(m.DerivativeMarketMultipliers) > 0 {
		for _, e := range m.DerivativeMarketMultipliers {
			l = e.Size()
			n += 1 + l + sovExchange(uint64(l))
		}
	}
	return n
}

func (m *CampaignRewardPool) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StartTimestamp != 0 {
		n += 1 + sovExchange(uint64(m.StartTimestamp))
	}
	if len(m.MaxCampaignRewards) > 0 {
		for _, e := range m.MaxCampaignRewards {
			l = e.Size()
			n += 1 + l + sovExchange(uint64(l))
		}
	}
	return n
}

func (m *TradingRewardCampaignInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CampaignDurationSeconds != 0 {
		n += 1 + sovExchange(uint64(m.CampaignDurationSeconds))
	}
	if len(m.QuoteDenoms) > 0 {
		for _, s := range m.QuoteDenoms {
			l = len(s)
			n += 1 + l + sovExchange(uint64(l))
		}
	}
	if m.TradingRewardBoostInfo != nil {
		l = m.TradingRewardBoostInfo.Size()
		n += 1 + l + sovExchange(uint64(l))
	}
	if len(m.DisqualifiedMarketIds) > 0 {
		for _, s := range m.DisqualifiedMarketIds {
			l = len(s)
			n += 1 + l + sovExchange(uint64(l))
		}
	}
	return n
}

func (m *FeeDiscountTierInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MakerDiscountRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.TakerDiscountRate.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.StakedAmount.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.Volume.Size()
	n += 1 + l + sovExchange(uint64(l))
	return n
}

func (m *FeeDiscountSchedule) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BucketCount != 0 {
		n += 1 + sovExchange(uint64(m.BucketCount))
	}
	if m.BucketDuration != 0 {
		n += 1 + sovExchange(uint64(m.BucketDuration))
	}
	if len(m.QuoteDenoms) > 0 {
		for _, s := range m.QuoteDenoms {
			l = len(s)
			n += 1 + l + sovExchange(uint64(l))
		}
	}
	if len(m.TierInfos) > 0 {
		for _, e := range m.TierInfos {
			l = e.Size()
			n += 1 + l + sovExchange(uint64(l))
		}
	}
	if len(m.DisqualifiedMarketIds) > 0 {
		for _, s := range m.DisqualifiedMarketIds {
			l = len(s)
			n += 1 + l + sovExchange(uint64(l))
		}
	}
	return n
}

func (m *FeeDiscountTierTTL) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Tier != 0 {
		n += 1 + sovExchange(uint64(m.Tier))
	}
	if m.TtlTimestamp != 0 {
		n += 1 + sovExchange(uint64(m.TtlTimestamp))
	}
	return n
}

func (m *VolumeRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MakerVolume.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.TakerVolume.Size()
	n += 1 + l + sovExchange(uint64(l))
	return n
}

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

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

func (m *SubaccountIDs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.SubaccountIds) > 0 {
		for _, b := range m.SubaccountIds {
			l = len(b)
			n += 1 + l + sovExchange(uint64(l))
		}
	}
	return n
}

func (m *TradeRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Timestamp != 0 {
		n += 1 + sovExchange(uint64(m.Timestamp))
	}
	l = m.Price.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.Quantity.Size()
	n += 1 + l + sovExchange(uint64(l))
	return n
}

func (m *Level) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.P.Size()
	n += 1 + l + sovExchange(uint64(l))
	l = m.Q.Size()
	n += 1 + l + sovExchange(uint64(l))
	return n
}

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

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

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

func (m *DenomDecimals) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Denom)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	if m.Decimals != 0 {
		n += 1 + sovExchange(uint64(m.Decimals))
	}
	return n
}

func (m *GrantAuthorization) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Grantee)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovExchange(uint64(l))
	return n
}

func (m *ActiveGrant) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Granter)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovExchange(uint64(l))
	return n
}

func (m *EffectiveGrant) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Granter)
	if l > 0 {
		n += 1 + l + sovExchange(uint64(l))
	}
	l = m.NetGrantedStake.Size()
	n += 1 + l + sovExchange(uint64(l))
	if m.IsValid {
		n += 2
	}
	return n
}

func sovExchange(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozExchange(x uint64) (n int) {
	return sovExchange(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Params) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExchange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Params: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpotMarketInstantListingFee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SpotMarketInstantListingFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DerivativeMarketInstantListingFee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DerivativeMarketInstantListingFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultSpotMakerFeeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DefaultSpotMakerFeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultSpotTakerFeeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DefaultSpotTakerFeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultDerivativeMakerFeeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DefaultDerivativeMakerFeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultDerivativeTakerFeeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DefaultDerivativeTakerFeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultInitialMarginRatio", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DefaultInitialMarginRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultMaintenanceMarginRatio", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DefaultMaintenanceMarginRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultFundingInterval", wireType)
			}
			m.DefaultFundingInterval = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DefaultFundingInterval |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FundingMultiple", wireType)
			}
			m.FundingMultiple = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FundingMultiple |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelayerFeeShareRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RelayerFeeShareRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultHourlyFundingRateCap", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DefaultHourlyFundingRateCap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultHourlyInterestRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DefaultHourlyInterestRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxDerivativeOrderSideCount", wireType)
			}
			m.MaxDerivativeOrderSideCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxDerivativeOrderSideCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InjRewardStakedRequirementThreshold", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.InjRewardStakedRequirementThreshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TradingRewardsVestingDuration", wireType)
			}
			m.TradingRewardsVestingDuration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TradingRewardsVestingDuration |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LiquidatorRewardShareRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.LiquidatorRewardShareRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BinaryOptionsMarketInstantListingFee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BinaryOptionsMarketInstantListingFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AtomicMarketOrderAccessLevel", wireType)
			}
			m.AtomicMarketOrderAccessLevel = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AtomicMarketOrderAccessLevel |= AtomicMarketOrderAccessLevel(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpotAtomicMarketOrderFeeMultiplier", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SpotAtomicMarketOrderFeeMultiplier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DerivativeAtomicMarketOrderFeeMultiplier", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DerivativeAtomicMarketOrderFeeMultiplier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BinaryOptionsAtomicMarketOrderFeeMultiplier", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BinaryOptionsAtomicMarketOrderFeeMultiplier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinimalProtocolFeeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinimalProtocolFeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 24:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsInstantDerivativeMarketLaunchEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsInstantDerivativeMarketLaunchEnabled = bool(v != 0)
		case 25:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PostOnlyModeHeightThreshold", wireType)
			}
			m.PostOnlyModeHeightThreshold = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PostOnlyModeHeightThreshold |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 26:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MarginDecreasePriceTimestampThresholdSeconds", wireType)
			}
			m.MarginDecreasePriceTimestampThresholdSeconds = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MarginDecreasePriceTimestampThresholdSeconds |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 27:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExchangeAdmins", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExchangeAdmins = append(m.ExchangeAdmins, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InjAuctionMaxCap", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.InjAuctionMaxCap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MarketFeeMultiplier) 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 ErrIntOverflowExchange
			}
			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: MarketFeeMultiplier: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MarketFeeMultiplier: 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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 FeeMultiplier", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.FeeMultiplier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DerivativeMarket) 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 ErrIntOverflowExchange
			}
			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: DerivativeMarket: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DerivativeMarket: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ticker", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ticker = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleBase", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OracleBase = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleQuote", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OracleQuote = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleType", wireType)
			}
			m.OracleType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OracleType |= types1.OracleType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleScaleFactor", wireType)
			}
			m.OracleScaleFactor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OracleScaleFactor |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QuoteDenom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QuoteDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MarketId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitialMarginRatio", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.InitialMarginRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaintenanceMarginRatio", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MaintenanceMarginRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MakerFeeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MakerFeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TakerFeeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TakerFeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelayerFeeShareRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RelayerFeeShareRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsPerpetual", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsPerpetual = bool(v != 0)
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= MarketStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinPriceTickSize", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinPriceTickSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinQuantityTickSize", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinQuantityTickSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinNotional", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinNotional.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Admin = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdminPermissions", wireType)
			}
			m.AdminPermissions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AdminPermissions |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BinaryOptionsMarket) 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 ErrIntOverflowExchange
			}
			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: BinaryOptionsMarket: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BinaryOptionsMarket: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ticker", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ticker = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleSymbol", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OracleSymbol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleProvider", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OracleProvider = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleType", wireType)
			}
			m.OracleType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OracleType |= types1.OracleType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleScaleFactor", wireType)
			}
			m.OracleScaleFactor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OracleScaleFactor |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTimestamp", wireType)
			}
			m.ExpirationTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExpirationTimestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SettlementTimestamp", wireType)
			}
			m.SettlementTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SettlementTimestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Admin = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QuoteDenom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QuoteDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MarketId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MakerFeeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MakerFeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TakerFeeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TakerFeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelayerFeeShareRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RelayerFeeShareRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= MarketStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinPriceTickSize", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinPriceTickSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinQuantityTickSize", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinQuantityTickSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SettlementPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v cosmossdk_io_math.LegacyDec
			m.SettlementPrice = &v
			if err := m.SettlementPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinNotional", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinNotional.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdminPermissions", wireType)
			}
			m.AdminPermissions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AdminPermissions |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExpiryFuturesMarketInfo) 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 ErrIntOverflowExchange
			}
			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: ExpiryFuturesMarketInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExpiryFuturesMarketInfo: 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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 ExpirationTimestamp", wireType)
			}
			m.ExpirationTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExpirationTimestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TwapStartTimestamp", wireType)
			}
			m.TwapStartTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TwapStartTimestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTwapStartPriceCumulative", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ExpirationTwapStartPriceCumulative.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SettlementPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SettlementPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PerpetualMarketInfo) 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 ErrIntOverflowExchange
			}
			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: PerpetualMarketInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PerpetualMarketInfo: 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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 HourlyFundingRateCap", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.HourlyFundingRateCap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HourlyInterestRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.HourlyInterestRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextFundingTimestamp", wireType)
			}
			m.NextFundingTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextFundingTimestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FundingInterval", wireType)
			}
			m.FundingInterval = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FundingInterval |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DerivativeMarketSettlementInfo) 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 ErrIntOverflowExchange
			}
			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: DerivativeMarketSettlementInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DerivativeMarketSettlementInfo: 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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 SettlementPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SettlementPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NextFundingTimestamp) 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 ErrIntOverflowExchange
			}
			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: NextFundingTimestamp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NextFundingTimestamp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextTimestamp", wireType)
			}
			m.NextTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextTimestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MidPriceAndTOB) 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 ErrIntOverflowExchange
			}
			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: MidPriceAndTOB: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MidPriceAndTOB: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MidPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v cosmossdk_io_math.LegacyDec
			m.MidPrice = &v
			if err := m.MidPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BestBuyPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v cosmossdk_io_math.LegacyDec
			m.BestBuyPrice = &v
			if err := m.BestBuyPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BestSellPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v cosmossdk_io_math.LegacyDec
			m.BestSellPrice = &v
			if err := m.BestSellPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SpotMarket) 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 ErrIntOverflowExchange
			}
			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: SpotMarket: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SpotMarket: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ticker", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ticker = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseDenom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BaseDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QuoteDenom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QuoteDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MakerFeeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MakerFeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TakerFeeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TakerFeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelayerFeeShareRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RelayerFeeShareRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MarketId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= MarketStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinPriceTickSize", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinPriceTickSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinQuantityTickSize", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinQuantityTickSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinNotional", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinNotional.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Admin = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdminPermissions", wireType)
			}
			m.AdminPermissions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AdminPermissions |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Deposit) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExchange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Deposit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Deposit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AvailableBalance", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.AvailableBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalBalance", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TotalBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SubaccountTradeNonce) 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 ErrIntOverflowExchange
			}
			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: SubaccountTradeNonce: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubaccountTradeNonce: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OrderInfo) 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 ErrIntOverflowExchange
			}
			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: OrderInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OrderInfo: 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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 FeeRecipient", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FeeRecipient = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Price.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quantity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Quantity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SpotOrder) 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 ErrIntOverflowExchange
			}
			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: SpotOrder: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SpotOrder: 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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 OrderInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OrderInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderType", wireType)
			}
			m.OrderType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OrderType |= OrderType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TriggerPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v cosmossdk_io_math.LegacyDec
			m.TriggerPrice = &v
			if err := m.TriggerPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SpotLimitOrder) 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 ErrIntOverflowExchange
			}
			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: SpotLimitOrder: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SpotLimitOrder: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OrderInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderType", wireType)
			}
			m.OrderType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OrderType |= OrderType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fillable", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Fillable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TriggerPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v cosmossdk_io_math.LegacyDec
			m.TriggerPrice = &v
			if err := m.TriggerPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderHash = append(m.OrderHash[:0], dAtA[iNdEx:postIndex]...)
			if m.OrderHash == nil {
				m.OrderHash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SpotMarketOrder) 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 ErrIntOverflowExchange
			}
			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: SpotMarketOrder: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SpotMarketOrder: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OrderInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BalanceHold", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BalanceHold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderHash = append(m.OrderHash[:0], dAtA[iNdEx:postIndex]...)
			if m.OrderHash == nil {
				m.OrderHash = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderType", wireType)
			}
			m.OrderType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OrderType |= OrderType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TriggerPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v cosmossdk_io_math.LegacyDec
			m.TriggerPrice = &v
			if err := m.TriggerPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DerivativeOrder) 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 ErrIntOverflowExchange
			}
			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: DerivativeOrder: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DerivativeOrder: 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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 OrderInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OrderInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderType", wireType)
			}
			m.OrderType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OrderType |= OrderType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Margin", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Margin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TriggerPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v cosmossdk_io_math.LegacyDec
			m.TriggerPrice = &v
			if err := m.TriggerPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SubaccountOrderbookMetadata) 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 ErrIntOverflowExchange
			}
			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: SubaccountOrderbookMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubaccountOrderbookMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VanillaLimitOrderCount", wireType)
			}
			m.VanillaLimitOrderCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VanillaLimitOrderCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReduceOnlyLimitOrderCount", wireType)
			}
			m.ReduceOnlyLimitOrderCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReduceOnlyLimitOrderCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AggregateReduceOnlyQuantity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.AggregateReduceOnlyQuantity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AggregateVanillaQuantity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.AggregateVanillaQuantity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VanillaConditionalOrderCount", wireType)
			}
			m.VanillaConditionalOrderCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VanillaConditionalOrderCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReduceOnlyConditionalOrderCount", wireType)
			}
			m.ReduceOnlyConditionalOrderCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReduceOnlyConditionalOrderCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DerivativeLimitOrder) 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 ErrIntOverflowExchange
			}
			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: DerivativeLimitOrder: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DerivativeLimitOrder: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OrderInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderType", wireType)
			}
			m.OrderType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OrderType |= OrderType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Margin", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Margin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fillable", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Fillable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TriggerPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v cosmossdk_io_math.LegacyDec
			m.TriggerPrice = &v
			if err := m.TriggerPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderHash = append(m.OrderHash[:0], dAtA[iNdEx:postIndex]...)
			if m.OrderHash == nil {
				m.OrderHash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DerivativeMarketOrder) 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 ErrIntOverflowExchange
			}
			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: DerivativeMarketOrder: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DerivativeMarketOrder: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OrderInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderType", wireType)
			}
			m.OrderType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OrderType |= OrderType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Margin", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Margin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MarginHold", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MarginHold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TriggerPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v cosmossdk_io_math.LegacyDec
			m.TriggerPrice = &v
			if err := m.TriggerPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderHash = append(m.OrderHash[:0], dAtA[iNdEx:postIndex]...)
			if m.OrderHash == nil {
				m.OrderHash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Position) 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 ErrIntOverflowExchange
			}
			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: Position: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Position: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsLong", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsLong = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quantity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Quantity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntryPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.EntryPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Margin", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Margin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CumulativeFundingEntry", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CumulativeFundingEntry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MarketOrderIndicator) 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 ErrIntOverflowExchange
			}
			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: MarketOrderIndicator: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MarketOrderIndicator: 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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 IsBuy", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsBuy = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TradeLog) 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 ErrIntOverflowExchange
			}
			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: TradeLog: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TradeLog: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quantity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Quantity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Price.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubaccountId", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubaccountId = append(m.SubaccountId[:0], dAtA[iNdEx:postIndex]...)
			if m.SubaccountId == nil {
				m.SubaccountId = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderHash = append(m.OrderHash[:0], dAtA[iNdEx:postIndex]...)
			if m.OrderHash == nil {
				m.OrderHash = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipientAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FeeRecipientAddress = append(m.FeeRecipientAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.FeeRecipientAddress == nil {
				m.FeeRecipientAddress = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DerivativeTradeLog) 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 ErrIntOverflowExchange
			}
			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: DerivativeTradeLog: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DerivativeTradeLog: 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 byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubaccountId = append(m.SubaccountId[:0], dAtA[iNdEx:postIndex]...)
			if m.SubaccountId == nil {
				m.SubaccountId = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PositionDelta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PositionDelta == nil {
				m.PositionDelta = &PositionDelta{}
			}
			if err := m.PositionDelta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payout", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Payout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderHash = append(m.OrderHash[:0], dAtA[iNdEx:postIndex]...)
			if m.OrderHash == nil {
				m.OrderHash = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipientAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FeeRecipientAddress = append(m.FeeRecipientAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.FeeRecipientAddress == nil {
				m.FeeRecipientAddress = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pnl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Pnl.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SubaccountDeposit) 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 ErrIntOverflowExchange
			}
			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: SubaccountDeposit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubaccountDeposit: 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 byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubaccountId = append(m.SubaccountId[:0], dAtA[iNdEx:postIndex]...)
			if m.SubaccountId == nil {
				m.SubaccountId = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Deposit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Deposit == nil {
				m.Deposit = &Deposit{}
			}
			if err := m.Deposit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FeeDiscountSchedule) 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 ErrIntOverflowExchange
			}
			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: FeeDiscountSchedule: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FeeDiscountSchedule: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketCount", wireType)
			}
			m.BucketCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BucketCount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketDuration", wireType)
			}
			m.BucketDuration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BucketDuration |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QuoteDenoms", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QuoteDenoms = append(m.QuoteDenoms, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TierInfos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TierInfos = append(m.TierInfos, &FeeDiscountTierInfo{})
			if err := m.TierInfos[len(m.TierInfos)-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 DisqualifiedMarketIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DisqualifiedMarketIds = append(m.DisqualifiedMarketIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FeeDiscountTierTTL) 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 ErrIntOverflowExchange
			}
			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: FeeDiscountTierTTL: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FeeDiscountTierTTL: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tier", wireType)
			}
			m.Tier = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Tier |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TtlTimestamp", wireType)
			}
			m.TtlTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TtlTimestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AccountRewards) 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 ErrIntOverflowExchange
			}
			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: AccountRewards: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AccountRewards: 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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 Rewards", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Rewards = append(m.Rewards, types.Coin{})
			if err := m.Rewards[len(m.Rewards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TradeRecords) 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 ErrIntOverflowExchange
			}
			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: TradeRecords: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TradeRecords: 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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 LatestTradeRecords", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LatestTradeRecords = append(m.LatestTradeRecords, &TradeRecord{})
			if err := m.LatestTradeRecords[len(m.LatestTradeRecords)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AggregateSubaccountVolumeRecord) 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 ErrIntOverflowExchange
			}
			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: AggregateSubaccountVolumeRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AggregateSubaccountVolumeRecord: 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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 MarketVolumes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AggregateAccountVolumeRecord) 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 ErrIntOverflowExchange
			}
			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: AggregateAccountVolumeRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AggregateAccountVolumeRecord: 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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 MarketVolumes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MarketVolume) 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 ErrIntOverflowExchange
			}
			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: MarketVolume: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MarketVolume: 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 ErrIntOverflowExchange
				}
				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 ErrInvalidLengthExchange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 Volume", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExchange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExchange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExchange
			}
			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 := skipExchange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExchange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

var (
	ErrInvalidLengthExchange        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowExchange          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupExchange = fmt.Errorf("proto: unexpected end of group")
)