venue

type AccountCapabilities struct {
	Snapshot bool
}

type Adapter interface {
	Venue() model.Venue
	Instruments() InstrumentProvider
	Data() DataClient
	Execution() ExecutionClient
	Capabilities() DeclaredCapabilities
	Close(context.Context) error
}

type Constructor func(context.Context, map[string]string) (Adapter, error)

type DataClient interface {
	Venue() model.Venue
	ClientID() string
	Instruments() InstrumentProvider
	Connect(context.Context) error
	Disconnect(context.Context) error
	Health() DataHealth
	FetchTicker(context.Context, model.InstrumentID) (model.Ticker, error)
	FetchOrderBook(context.Context, model.InstrumentID, int) (model.OrderBook, error)
}

type DataHealth struct {
	Connected       bool
	InstrumentReady bool
	LastEventTime   time.Time
	LastError       error
}

type DeclaredCapabilities struct {
	Venue       model.Venue
	Instruments bool
	MarketData  MarketDataCapabilities
	Execution   ExecutionCapabilities
	Account     AccountCapabilities
}

type ExecutionCapabilities struct {
	Submit          bool
	Cancel          bool
	Modify          bool
	Query           bool
	OrderReports    bool
	FillReports     bool
	PositionReports bool
	PrivateStream   bool
	Resubscribe     bool
	MassStatus      bool
	OrderLists      bool
}

type ExecutionClient interface {
	Venue() model.Venue
	AccountID() model.AccountID
	Connect(context.Context) error
	Disconnect(context.Context) error
	Health() ExecutionHealth
	QueryAccount(context.Context) (model.AccountSnapshot, error)
	SubmitOrder(context.Context, model.SubmitOrder) (model.OrderStatusReport, error)
	CancelOrder(context.Context, model.CancelOrder) (model.OrderStatusReport, error)
	GenerateOrderStatusReports(context.Context, model.InstrumentID) ([]model.OrderStatusReport, error)
	Events() <-chan model.ExecutionEvent
}

type ExecutionHealth struct {
	Connected     bool
	AccountReady  bool
	LastEventTime time.Time
	LastError     error
}

type ExecutionMassStatusGenerator interface {
	GenerateExecutionMassStatus(context.Context, model.GenerateExecutionMassStatus) (model.ExecutionMassStatus, error)
}

type ExecutionResubscriber interface {
	ResubscribeExecution(context.Context) error
}

type FillReportGenerator interface {
	GenerateFillReports(context.Context, model.InstrumentID) ([]model.FillReport, error)
}

type FundingRateProvider interface {
	FetchFundingRate(context.Context, model.InstrumentID) (model.FundingRate, error)
}

type InstrumentProvider interface {
	LoadAll(context.Context) error
	Get(model.InstrumentID) (model.Instrument, bool)
	List() []model.Instrument
}

type MarketDataCapabilities struct {
	Snapshots         bool
	Ticker            bool
	OrderBook         bool
	TickerStream      bool
	OrderBookStream   bool
	TradeTicks        bool
	QuoteTicks        bool
	Bars              bool
	FundingRates      bool
	FundingRateStream bool
	Streams           bool
}

type OrderListSubmitter interface {
	SubmitOrderList(context.Context, model.SubmitOrderList) ([]model.OrderStatusReport, error)
}

type OrderModifier interface {
	ModifyOrder(context.Context, model.ModifyOrder) (model.OrderStatusReport, error)
}

type OrderQuerier interface {
	QueryOrder(context.Context, model.QueryOrder) (model.OrderStatusReport, error)
}

type PositionStatusReportGenerator interface {
	GeneratePositionStatusReports(context.Context, model.InstrumentID) ([]model.PositionStatusReport, error)
}

type Registry struct {
	// contains filtered or unexported fields
}

type StreamingDataClient interface {
	SubscribeMarketData(context.Context, model.SubscribeMarketData) error
	UnsubscribeMarketData(context.Context, model.SubscribeMarketData) error
	Events() <-chan model.MarketEvent
}