matches.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: jinxprotocol/clob/matches.proto

package types

import (
	fmt "fmt"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	types "github.com/jinxprotocol/v4-chain/protocol/x/subaccounts/types"
	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

// ClobMatch represents an operations queue entry around all different types
// of matches, specifically regular matches, liquidation matches, and
// deleveraging matches.
type ClobMatch struct {
	// The match type that this message includes.
	//
	// Types that are valid to be assigned to Match:
	//	*ClobMatch_MatchOrders
	//	*ClobMatch_MatchPerpetualLiquidation
	//	*ClobMatch_MatchPerpetualDeleveraging
	Match isClobMatch_Match `protobuf_oneof:"match"`
}

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

var xxx_messageInfo_ClobMatch proto.InternalMessageInfo

type isClobMatch_Match interface {
	isClobMatch_Match()
	MarshalTo([]byte) (int, error)
	Size() int
}

type ClobMatch_MatchOrders struct {
	MatchOrders *MatchOrders `protobuf:"bytes,1,opt,name=match_orders,json=matchOrders,proto3,oneof" json:"match_orders,omitempty"`
}
type ClobMatch_MatchPerpetualLiquidation struct {
	MatchPerpetualLiquidation *MatchPerpetualLiquidation `protobuf:"bytes,2,opt,name=match_perpetual_liquidation,json=matchPerpetualLiquidation,proto3,oneof" json:"match_perpetual_liquidation,omitempty"`
}
type ClobMatch_MatchPerpetualDeleveraging struct {
	MatchPerpetualDeleveraging *MatchPerpetualDeleveraging `protobuf:"bytes,3,opt,name=match_perpetual_deleveraging,json=matchPerpetualDeleveraging,proto3,oneof" json:"match_perpetual_deleveraging,omitempty"`
}

func (*ClobMatch_MatchOrders) isClobMatch_Match()                {}
func (*ClobMatch_MatchPerpetualLiquidation) isClobMatch_Match()  {}
func (*ClobMatch_MatchPerpetualDeleveraging) isClobMatch_Match() {}

func (m *ClobMatch) GetMatch() isClobMatch_Match {
	if m != nil {
		return m.Match
	}
	return nil
}

func (m *ClobMatch) GetMatchOrders() *MatchOrders {
	if x, ok := m.GetMatch().(*ClobMatch_MatchOrders); ok {
		return x.MatchOrders
	}
	return nil
}

func (m *ClobMatch) GetMatchPerpetualLiquidation() *MatchPerpetualLiquidation {
	if x, ok := m.GetMatch().(*ClobMatch_MatchPerpetualLiquidation); ok {
		return x.MatchPerpetualLiquidation
	}
	return nil
}

func (m *ClobMatch) GetMatchPerpetualDeleveraging() *MatchPerpetualDeleveraging {
	if x, ok := m.GetMatch().(*ClobMatch_MatchPerpetualDeleveraging); ok {
		return x.MatchPerpetualDeleveraging
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ClobMatch) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ClobMatch_MatchOrders)(nil),
		(*ClobMatch_MatchPerpetualLiquidation)(nil),
		(*ClobMatch_MatchPerpetualDeleveraging)(nil),
	}
}

// MakerFill represents the filled amount of a matched maker order.
type MakerFill struct {
	// The filled amount of the matched maker order, in base quantums.
	// TODO(CLOB-571): update to use SerializableInt.
	FillAmount uint64 `protobuf:"varint,1,opt,name=fill_amount,json=fillAmount,proto3" json:"fill_amount,omitempty"`
	// The `OrderId` of the matched maker order.
	MakerOrderId OrderId `protobuf:"bytes,2,opt,name=maker_order_id,json=makerOrderId,proto3" json:"maker_order_id"`
}

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

var xxx_messageInfo_MakerFill proto.InternalMessageInfo

func (m *MakerFill) GetFillAmount() uint64 {
	if m != nil {
		return m.FillAmount
	}
	return 0
}

func (m *MakerFill) GetMakerOrderId() OrderId {
	if m != nil {
		return m.MakerOrderId
	}
	return OrderId{}
}

// MatchOrders is an injected message used for matching orders.
type MatchOrders struct {
	// The `OrderId` of the taker order.
	TakerOrderId OrderId `protobuf:"bytes,1,opt,name=taker_order_id,json=takerOrderId,proto3" json:"taker_order_id"`
	// An ordered list of fills created by this taker order.
	Fills []MakerFill `protobuf:"bytes,2,rep,name=fills,proto3" json:"fills"`
}

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

var xxx_messageInfo_MatchOrders proto.InternalMessageInfo

func (m *MatchOrders) GetTakerOrderId() OrderId {
	if m != nil {
		return m.TakerOrderId
	}
	return OrderId{}
}

func (m *MatchOrders) GetFills() []MakerFill {
	if m != nil {
		return m.Fills
	}
	return nil
}

// MatchPerpetualLiquidation is an injected message used for liquidating a
// subaccount.
type MatchPerpetualLiquidation struct {
	// ID of the subaccount that was liquidated.
	Liquidated types.SubaccountId `protobuf:"bytes,1,opt,name=liquidated,proto3" json:"liquidated"`
	// The ID of the clob pair involved in the liquidation.
	ClobPairId uint32 `protobuf:"varint,2,opt,name=clob_pair_id,json=clobPairId,proto3" json:"clob_pair_id,omitempty"`
	// The ID of the perpetual involved in the liquidation.
	PerpetualId uint32 `protobuf:"varint,3,opt,name=perpetual_id,json=perpetualId,proto3" json:"perpetual_id,omitempty"`
	// The total size of the liquidation order including any unfilled size.
	TotalSize uint64 `protobuf:"varint,4,opt,name=total_size,json=totalSize,proto3" json:"total_size,omitempty"`
	// `true` if liquidating a short position, `false` otherwise.
	IsBuy bool `protobuf:"varint,5,opt,name=is_buy,json=isBuy,proto3" json:"is_buy,omitempty"`
	// An ordered list of fills created by this liquidation.
	Fills []MakerFill `protobuf:"bytes,6,rep,name=fills,proto3" json:"fills"`
}

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

var xxx_messageInfo_MatchPerpetualLiquidation proto.InternalMessageInfo

func (m *MatchPerpetualLiquidation) GetLiquidated() types.SubaccountId {
	if m != nil {
		return m.Liquidated
	}
	return types.SubaccountId{}
}

func (m *MatchPerpetualLiquidation) GetClobPairId() uint32 {
	if m != nil {
		return m.ClobPairId
	}
	return 0
}

func (m *MatchPerpetualLiquidation) GetPerpetualId() uint32 {
	if m != nil {
		return m.PerpetualId
	}
	return 0
}

func (m *MatchPerpetualLiquidation) GetTotalSize() uint64 {
	if m != nil {
		return m.TotalSize
	}
	return 0
}

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

func (m *MatchPerpetualLiquidation) GetFills() []MakerFill {
	if m != nil {
		return m.Fills
	}
	return nil
}

// MatchPerpetualDeleveraging is an injected message used for deleveraging a
// subaccount.
type MatchPerpetualDeleveraging struct {
	// ID of the subaccount that was liquidated.
	Liquidated types.SubaccountId `protobuf:"bytes,1,opt,name=liquidated,proto3" json:"liquidated"`
	// The ID of the perpetual that was liquidated.
	PerpetualId uint32 `protobuf:"varint,2,opt,name=perpetual_id,json=perpetualId,proto3" json:"perpetual_id,omitempty"`
	// An ordered list of fills created by this liquidation.
	Fills []MatchPerpetualDeleveraging_Fill `protobuf:"bytes,3,rep,name=fills,proto3" json:"fills"`
	// Flag denoting whether the deleveraging operation was for the purpose
	// of final settlement. Final settlement matches are at the oracle price,
	// whereas deleveraging happens at the bankruptcy price of the deleveraged
	// subaccount.
	IsFinalSettlement bool `protobuf:"varint,4,opt,name=is_final_settlement,json=isFinalSettlement,proto3" json:"is_final_settlement,omitempty"`
}

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

var xxx_messageInfo_MatchPerpetualDeleveraging proto.InternalMessageInfo

func (m *MatchPerpetualDeleveraging) GetLiquidated() types.SubaccountId {
	if m != nil {
		return m.Liquidated
	}
	return types.SubaccountId{}
}

func (m *MatchPerpetualDeleveraging) GetPerpetualId() uint32 {
	if m != nil {
		return m.PerpetualId
	}
	return 0
}

func (m *MatchPerpetualDeleveraging) GetFills() []MatchPerpetualDeleveraging_Fill {
	if m != nil {
		return m.Fills
	}
	return nil
}

func (m *MatchPerpetualDeleveraging) GetIsFinalSettlement() bool {
	if m != nil {
		return m.IsFinalSettlement
	}
	return false
}

// Fill represents a fill between the liquidated and offsetting subaccount.
type MatchPerpetualDeleveraging_Fill struct {
	// ID of the subaccount that was used to offset the liquidated subaccount's
	// position.
	OffsettingSubaccountId types.SubaccountId `protobuf:"bytes,1,opt,name=offsetting_subaccount_id,json=offsettingSubaccountId,proto3" json:"offsetting_subaccount_id"`
	// The amount filled between the liquidated and offsetting position, in
	// base quantums.
	// TODO(CLOB-571): update to use SerializableInt.
	FillAmount uint64 `protobuf:"varint,2,opt,name=fill_amount,json=fillAmount,proto3" json:"fill_amount,omitempty"`
}

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

var xxx_messageInfo_MatchPerpetualDeleveraging_Fill proto.InternalMessageInfo

func (m *MatchPerpetualDeleveraging_Fill) GetOffsettingSubaccountId() types.SubaccountId {
	if m != nil {
		return m.OffsettingSubaccountId
	}
	return types.SubaccountId{}
}

func (m *MatchPerpetualDeleveraging_Fill) GetFillAmount() uint64 {
	if m != nil {
		return m.FillAmount
	}
	return 0
}

func init() {
	proto.RegisterType((*ClobMatch)(nil), "jinxprotocol.clob.ClobMatch")
	proto.RegisterType((*MakerFill)(nil), "jinxprotocol.clob.MakerFill")
	proto.RegisterType((*MatchOrders)(nil), "jinxprotocol.clob.MatchOrders")
	proto.RegisterType((*MatchPerpetualLiquidation)(nil), "jinxprotocol.clob.MatchPerpetualLiquidation")
	proto.RegisterType((*MatchPerpetualDeleveraging)(nil), "jinxprotocol.clob.MatchPerpetualDeleveraging")
	proto.RegisterType((*MatchPerpetualDeleveraging_Fill)(nil), "jinxprotocol.clob.MatchPerpetualDeleveraging.Fill")
}

func init() { proto.RegisterFile("jinxprotocol/clob/matches.proto", fileDescriptor_a30d2c63162f112a) }

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

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

func (m *ClobMatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Match != nil {
		{
			size := m.Match.Size()
			i -= size
			if _, err := m.Match.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *ClobMatch_MatchOrders) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MatchOrders != nil {
		{
			size, err := m.MatchOrders.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMatches(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *ClobMatch_MatchPerpetualLiquidation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ClobMatch_MatchPerpetualLiquidation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MatchPerpetualLiquidation != nil {
		{
			size, err := m.MatchPerpetualLiquidation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMatches(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *ClobMatch_MatchPerpetualDeleveraging) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ClobMatch_MatchPerpetualDeleveraging) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MatchPerpetualDeleveraging != nil {
		{
			size, err := m.MatchPerpetualDeleveraging.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMatches(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *MakerFill) 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 *MakerFill) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MakerFill) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.MakerOrderId.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMatches(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.FillAmount != 0 {
		i = encodeVarintMatches(dAtA, i, uint64(m.FillAmount))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MatchPerpetualLiquidation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Fills) > 0 {
		for iNdEx := len(m.Fills) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Fills[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMatches(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.IsBuy {
		i--
		if m.IsBuy {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.TotalSize != 0 {
		i = encodeVarintMatches(dAtA, i, uint64(m.TotalSize))
		i--
		dAtA[i] = 0x20
	}
	if m.PerpetualId != 0 {
		i = encodeVarintMatches(dAtA, i, uint64(m.PerpetualId))
		i--
		dAtA[i] = 0x18
	}
	if m.ClobPairId != 0 {
		i = encodeVarintMatches(dAtA, i, uint64(m.ClobPairId))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.Liquidated.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMatches(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *MatchPerpetualDeleveraging) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsFinalSettlement {
		i--
		if m.IsFinalSettlement {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.Fills) > 0 {
		for iNdEx := len(m.Fills) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Fills[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMatches(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.PerpetualId != 0 {
		i = encodeVarintMatches(dAtA, i, uint64(m.PerpetualId))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.Liquidated.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMatches(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *MatchPerpetualDeleveraging_Fill) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FillAmount != 0 {
		i = encodeVarintMatches(dAtA, i, uint64(m.FillAmount))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.OffsettingSubaccountId.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMatches(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func encodeVarintMatches(dAtA []byte, offset int, v uint64) int {
	offset -= sovMatches(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ClobMatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Match != nil {
		n += m.Match.Size()
	}
	return n
}

func (m *ClobMatch_MatchOrders) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MatchOrders != nil {
		l = m.MatchOrders.Size()
		n += 1 + l + sovMatches(uint64(l))
	}
	return n
}
func (m *ClobMatch_MatchPerpetualLiquidation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MatchPerpetualLiquidation != nil {
		l = m.MatchPerpetualLiquidation.Size()
		n += 1 + l + sovMatches(uint64(l))
	}
	return n
}
func (m *ClobMatch_MatchPerpetualDeleveraging) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MatchPerpetualDeleveraging != nil {
		l = m.MatchPerpetualDeleveraging.Size()
		n += 1 + l + sovMatches(uint64(l))
	}
	return n
}
func (m *MakerFill) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FillAmount != 0 {
		n += 1 + sovMatches(uint64(m.FillAmount))
	}
	l = m.MakerOrderId.Size()
	n += 1 + l + sovMatches(uint64(l))
	return n
}

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

func (m *MatchPerpetualLiquidation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Liquidated.Size()
	n += 1 + l + sovMatches(uint64(l))
	if m.ClobPairId != 0 {
		n += 1 + sovMatches(uint64(m.ClobPairId))
	}
	if m.PerpetualId != 0 {
		n += 1 + sovMatches(uint64(m.PerpetualId))
	}
	if m.TotalSize != 0 {
		n += 1 + sovMatches(uint64(m.TotalSize))
	}
	if m.IsBuy {
		n += 2
	}
	if len(m.Fills) > 0 {
		for _, e := range m.Fills {
			l = e.Size()
			n += 1 + l + sovMatches(uint64(l))
		}
	}
	return n
}

func (m *MatchPerpetualDeleveraging) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Liquidated.Size()
	n += 1 + l + sovMatches(uint64(l))
	if m.PerpetualId != 0 {
		n += 1 + sovMatches(uint64(m.PerpetualId))
	}
	if len(m.Fills) > 0 {
		for _, e := range m.Fills {
			l = e.Size()
			n += 1 + l + sovMatches(uint64(l))
		}
	}
	if m.IsFinalSettlement {
		n += 2
	}
	return n
}

func (m *MatchPerpetualDeleveraging_Fill) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.OffsettingSubaccountId.Size()
	n += 1 + l + sovMatches(uint64(l))
	if m.FillAmount != 0 {
		n += 1 + sovMatches(uint64(m.FillAmount))
	}
	return n
}

func sovMatches(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMatches(x uint64) (n int) {
	return sovMatches(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ClobMatch) 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 ErrIntOverflowMatches
			}
			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: ClobMatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClobMatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MatchOrders", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMatches
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMatches
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMatches
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &MatchOrders{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Match = &ClobMatch_MatchOrders{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MatchPerpetualLiquidation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMatches
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMatches
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMatches
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &MatchPerpetualLiquidation{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Match = &ClobMatch_MatchPerpetualLiquidation{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MatchPerpetualDeleveraging", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMatches
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMatches
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMatches
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &MatchPerpetualDeleveraging{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Match = &ClobMatch_MatchPerpetualDeleveraging{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMatches(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMatches
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MatchPerpetualLiquidation) 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 ErrIntOverflowMatches
			}
			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: MatchPerpetualLiquidation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MatchPerpetualLiquidation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Liquidated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMatches
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMatches
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMatches
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Liquidated.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClobPairId", wireType)
			}
			m.ClobPairId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMatches
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ClobPairId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PerpetualId", wireType)
			}
			m.PerpetualId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMatches
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PerpetualId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalSize", wireType)
			}
			m.TotalSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMatches
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMatches
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsBuy = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fills", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMatches
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMatches
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMatches
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fills = append(m.Fills, MakerFill{})
			if err := m.Fills[len(m.Fills)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMatches(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMatches
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MatchPerpetualDeleveraging) 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 ErrIntOverflowMatches
			}
			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: MatchPerpetualDeleveraging: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MatchPerpetualDeleveraging: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Liquidated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMatches
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMatches
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMatches
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Liquidated.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PerpetualId", wireType)
			}
			m.PerpetualId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMatches
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PerpetualId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fills", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMatches
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMatches
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMatches
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fills = append(m.Fills, MatchPerpetualDeleveraging_Fill{})
			if err := m.Fills[len(m.Fills)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsFinalSettlement", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMatches
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsFinalSettlement = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipMatches(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMatches
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

var (
	ErrInvalidLengthMatches        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMatches          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMatches = fmt.Errorf("proto: unexpected end of group")
)