common

type Asset ¶

type Asset struct {
	ID     AssetID     `json:"id"`
	Symbol AssetSymbol `json:"symbol"`
}

An asset represents an asset on Cryptowatch. Assets are the building blocks for instruments. Examples: btc, usd, eth

func (a Asset) String() string

type AssetID ¶

type AssetID int

func (a AssetID) String() string

type AssetSymbol ¶

type AssetSymbol string

func (as AssetSymbol) String() string

type Balance ¶

type Balance struct {
	FundingType FundingType
	Asset       Asset
	Amount      decimal.Decimal
}

Balance is the amount you have of a particular asset.

type Balances ¶

type Balances map[Exchange][]Balance

func (b Balances) All() []Balance

type CancelOrderParams ¶

type CancelOrderParams struct {
	MarketID MarketID
	OrderID  string
}

CancelOrderParams contains the necessary options for canceling an existing order with the trade client. See TradeClient.CancelOrder.

type Exchange ¶

type Exchange struct {
	ID     ExchangeID     `json:"id"`
	Symbol ExchangeSymbol `json:"symbol"`
}

Exchange represents an exchange on Cryptowatch. Examples: kraken, bitfinex, coinbase-pro

type ExchangeID ¶

type ExchangeID int

type ExchangeSymbol ¶

type ExchangeSymbol string

type FundingType ¶

type FundingType int32

FundingType represents the funding type for an order; e.g. "spot" or "margin". The funding types available depend on the exchange, as well as your account's permissions on the exchange.

const (
	SpotFunding FundingType = iota
	MarginFunding
	FuturesFunding
)

type GetAssetParams ¶

type GetAssetParams struct {
	ID     AssetID
	Symbol AssetSymbol
}

type Instrument ¶

type Instrument struct {
	ID    InstrumentID `json:"id"`
	Base  Asset        `json:"base"`
	Quote Asset        `json:"quote"`
}

Instrument represents an instrument on Cryptowatch, which is essentially a base+quote, or if it is a futures market, a settlement frequency as well. Examples: btcusd, ethusd, btcusdt

type InstrumentID ¶

type InstrumentID int

type Interval ¶

type Interval struct {
	Period Period
	OHLC   OHLC

	// CloseTime is the time at which the Interval ended.
	CloseTime time.Time

	// VolumeBase is the amount of volume traded over this Interval, represented
	// in the base currency.
	VolumeBase decimal.Decimal

	// VolumeQuote is the amount of volume traded over this Interval, represented
	// in the quote currency.
	VolumeQuote decimal.Decimal
}

An interval represetns OHLC data for a particular Period and CloseTime.

type IntervalsUpdate ¶

type IntervalsUpdate struct {
	Intervals []Interval
}

IntervalsUpdate represents an update for OHLC data, at all relevant periods. Intervals is represented as a slice because more than one interval update can occur at the same time for different periods. For example, Period1M and Period3M will overlap every 3 minutes, so that IntervalsUpdate will contain both intervals.

type Market ¶

type Market struct {
	ID         MarketID   `json:"id"`
	Exchange   Exchange   `json:"exchange"`
	Instrument Instrument `json:"instrument"`
}

Market represents a market on Cryptowatch. A market consists of an exchange and currency pair. For example, Kraken BTC/USD. IDs are used instead of names to avoid inconsistencies associated with name changes. Example: kraken:btcusd, bitfinex:btcusd

func (m Market) String() string

func (m Market) Symbol() MarketSymbol

type MarketID ¶

type MarketID int

func (m MarketID) String() string

type MarketParams ¶

type MarketParams struct {
	Symbol MarketSymbol
	ID     MarketID
}

type MarketSymbol ¶

type MarketSymbol struct {
	Exchange ExchangeSymbol
	Base     AssetSymbol
	Quote    AssetSymbol
}

func (ms MarketSymbol) String() string

type MarketUpdate ¶

type MarketUpdate struct {
	OrderBookSnapshot     *OrderBookSnapshot     `json:"OrderBookSnapshot,omitempty"`
	OrderBookDelta        *OrderBookDelta        `json:"OrderBookDelta,omitempty"`
	OrderBookSpreadUpdate *OrderBookSpreadUpdate `json:"OrderBookSpreadUpdate,omitempty"`
	TradesUpdate          *TradesUpdate          `json:"TradesUpdate,omitempty"`
	IntervalsUpdate       *IntervalsUpdate       `json:"IntervalsUpdate,omitempty"`
	SummaryUpdate         *SummaryUpdate         `json:"SummaryUpdate,omitempty"`
	SparklineUpdate       *SparklineUpdate       `json:"SparklineUpdate,omitempty"`
}

MarketUpdate is a container for all market data callbacks. For any MarketUpdate intance, it will only ever have one of its properties non-null. See OnMarketUpdate.

func (v MarketUpdate) String() string

type OHLC ¶

type OHLC struct {
	Open  decimal.Decimal
	High  decimal.Decimal
	Low   decimal.Decimal
	Close decimal.Decimal
}

OHLC contains the open, low, high, and close prices for a given Interval.

type OrderBookDelta ¶

type OrderBookDelta struct {
	// SeqNum is used to make sure deltas are processed in order.
	// See the SeqNum definition for more information.
	SeqNum SeqNum

	Bids OrderDeltas
	Asks OrderDeltas
}

OrderBookDelta represents an order book delta update, which is the minimum amount of data necessary to keep a local order book up to date. Since order book snapshots are throttled at 1 per minute, subscribing to the delta updates is the best way to keep an order book up to date.

func (delta OrderBookDelta) Empty() bool

type OrderBookSnapshot ¶

type OrderBookSnapshot struct {
	// SeqNum	is the sequence number of the last order book delta received.
	// Since snapshots are broadcast on a 1-minute interval regardless of updates,
	// it's possible this value doesn't change.
	// See the SeqNum definition for more information.
	SeqNum SeqNum

	Bids []PublicOrder
	Asks []PublicOrder
}

OrderBookSnapshot represents a full order book snapshot.

func (s *OrderBookSnapshot) ApplyDelta(obd OrderBookDelta) (OrderBookSnapshot, error)

func (s *OrderBookSnapshot) ApplyDeltaOpt(obd OrderBookDelta, ignoreSeqNum bool) (OrderBookSnapshot, error)

func (obs *OrderBookSnapshot) Copy() OrderBookSnapshot

func (s *OrderBookSnapshot) Empty() bool

func (s *OrderBookSnapshot) GetDeltasAgainst(oldSnapshot OrderBookSnapshot) OrderBookDelta

func (s *OrderBookSnapshot) IsValid() bool

type OrderBookSpreadUpdate ¶

type OrderBookSpreadUpdate struct {
	Timestamp time.Time
	Bid       PublicOrder
	Ask       PublicOrder
}

OrderBookSpreadUpdate represents the most recent order book spread. It consists of the best current bid and as price.

type OrderDeltas ¶

type OrderDeltas struct {
	// Set is a list of orders used to add or replace orders on an order book.
	// Each order in Set is guaranteed to be a different price. For each of them,
	// if the order at that price exists on the book, replace it. If an order
	// at that price does not exist, add it to the book.
	Set []PublicOrder

	// Remove is a list of prices. To apply to an order book, remove all orders
	// of that price from that book.
	Remove []decimal.Decimal
}

OrderDeltas are used to update an order book, either by setting (adding) new PublicOrders, or removing orders at specific prices.

func GetDeltasAgainst(oldOrders, newOrders []PublicOrder, reversed bool) OrderDeltas

func (d OrderDeltas) Empty() bool

type OrderSide ¶

type OrderSide int32

OrderSide represents the order side; e.g. "buy" or "sell".

const (
	OrderSideUnknown OrderSide = iota
	OrderSideBuy
	OrderSideSell
)

func (os OrderSide) String() string

type OrderType ¶

type OrderType int32

OrderType represents the type of order; e.g. "market" or "limit". There are 13 different types of orders. Those available depend on the exchange. Refer to the exchange's documentation for what order types are available.

const (
	MarketOrder OrderType = iota
	LimitOrder
	StopLossOrder
	StopLossLimitOrder
	TakeProfitOrder
	TakeProfitLimitOrder
	StopLossTakeProfitOrder
	StopLossTakeProfitLimitOrder
	TrailingStopLossOrder
	TrailingStopLossLimitOrder
	StopLossAndLimitOrder
	FillOrKillOrder
	SettlePositionOrder
)

type Pair ¶

type Pair struct {
	ID PairID
}

Pair represents the currency pair as defined by the Cryptowatch API: https://api.cryptowat.ch/pairs

type PairID ¶

type PairID string

type PairUpdate ¶

type PairUpdate struct {
	VWAPUpdate        *VWAPUpdate        `json:"VWAPUpdate,omitempty"`
	PerformanceUpdate *PerformanceUpdate `json:"PerformanceUpdate,omitempty"`
	TrendlineUpdate   *TrendlineUpdate   `json:"TrendlineUpdate,omitempty"`
}

PairUpdate is a container for all pair data callbacks. For any PairUpdate instance, it will only ever have one of its properties non-null. See OnPairUpdate.

func (v PairUpdate) String() string

type PerformanceUpdate ¶

type PerformanceUpdate struct {
	Window      PerformanceWindow
	Performance decimal.Decimal
}

PerformanceUpdate represents the most recent performance update for a market over a particular window. TODO explain calculation

type PerformanceWindow ¶

type PerformanceWindow string

PerformanceWindow represents the time window over which performance is calculated.

const (
	PerfWindow24h PerformanceWindow = "24h"
	PerfWindow1w  PerformanceWindow = "1w"
	PerfWindow1m  PerformanceWindow = "1m"
	PerfWindow3m  PerformanceWindow = "3m"
	PerfWindow6m  PerformanceWindow = "6m"
	PerfWindowYTD PerformanceWindow = "ytd"
	PerfWindow1y  PerformanceWindow = "1y"
	PerfWindow2y  PerformanceWindow = "2y"
	PerfWindow3y  PerformanceWindow = "3y"
	PerfWindow4y  PerformanceWindow = "4y"
	PerfWindow5y  PerformanceWindow = "5y"
)

type Period ¶

type Period string

Period is the number of seconds in an Interval.

const (
	Period1M         Period = "60"
	Period3M         Period = "180"
	Period5M         Period = "300"
	Period15M        Period = "900"
	Period30M        Period = "1800"
	Period1H         Period = "3600"
	Period2H         Period = "7200"
	Period4H         Period = "14400"
	Period6H         Period = "21600"
	Period12H        Period = "43200"
	Period1D         Period = "86400"
	Period3D         Period = "259200"
	Period1WThursday Period = "604800"
	Period1WMonday   Period = "604800_Monday"
)

func (p Period) Duration() time.Duration

type PlaceOrderParams ¶

type PlaceOrderParams struct {
	MarketID    MarketID
	PriceParams PriceParams
	Amount      string
	OrderSide   OrderSide
	OrderType   OrderType
	FundingType FundingType
	Leverage    string
	ExpireTime  time.Time
}

PlaceOrderParams contains the necessary options for creating a new order with the trade client. See TradeClient.PlaceOrder.

type PriceParam ¶

type PriceParam struct {
	Value string
	Type  PriceParamType
}

PriceParam is used as input for an Order.

type PriceParamType ¶

type PriceParamType int32

PriceParamType represents the type of price parameter used in PriceParams.

const (
	AbsoluteValuePrice PriceParamType = iota
	RelativeValuePrice
	RelativePercentValuePrice
)

type PriceParams ¶

type PriceParams []*PriceParam

PriceParams is a list of price parameters that define the input to an order. Usually you will just need one PriceParam input, but some order types take multiple PriceParam inputs, such as TrailingStopLossOrder. TODO document different PriceParam uses

type PrivateOrder ¶

type PrivateOrder struct {
	PriceParams PriceParams
	Amount      string
	OrderSide   OrderSide
	OrderType   OrderType
	FundingType FundingType
	ExpireTime  time.Time

	// Set by server and updated internally by client.
	// ID previously was ExternalID.
	ID           string
	Timestamp    time.Time
	Leverage     string
	CurrentStop  string
	InitialStop  string
	AmountFilled string

	// Broker error code; 0 if successful
	Error int32
}

PrivateOrder represents an order you have placed on an exchange, either through the TradeClient, or on the exchange itself.

func (o PrivateOrder) CacheKey(mID MarketID) string

func (o PrivateOrder) String() string

type PrivateOrders ¶

type PrivateOrders []PrivateOrder

func (os PrivateOrders) Len() int

func (os PrivateOrders) Less(i, j int) bool

func (os PrivateOrders) Swap(i, j int)

type PrivatePosition ¶

type PrivatePosition struct {
	ExternalID   string
	Timestamp    time.Time
	OrderSide    OrderSide
	AvgPrice     string
	AmountOpen   string
	AmountClosed string
	OrderIDs     []string
	TradeIDs     []string
}

PrivatePosition represents one of your positions on an exchange.

type PrivatePositions ¶

type PrivatePositions []PrivatePosition

func (ps PrivatePositions) Len() int

func (ps PrivatePositions) Less(i, j int) bool

func (ps PrivatePositions) Swap(i, j int)

type PrivateTrade ¶

type PrivateTrade struct {
	ExternalID string
	OrderID    string
	Timestamp  time.Time
	Price      string
	Amount     string
	OrderSide  OrderSide
}

PrivateTrade represents a trade made on your account.

type PrivateTrades ¶

type PrivateTrades []PrivateTrade

func (ts PrivateTrades) Len() int

func (ts PrivateTrades) Less(i, j int) bool

func (ts PrivateTrades) Swap(i, j int)

type PublicOrder ¶

type PublicOrder struct {
	Price  decimal.Decimal
	Amount decimal.Decimal
}

PublicOrder represents a public order placed on an exchange. They often come as a slice of PublicOrder, which come with order book updates.

func ApplyDeltas(orders []PublicOrder, deltas *OrderDeltas, reverse bool) []PublicOrder

type PublicTrade ¶

type PublicTrade struct {
	// ExternalID is given by the exchange, and not Cryptowatch. NOTE some of
	// these may be "0" since we still use int64 on the back end to represent
	// these IDs, and some are strings.
	ExternalID string
	Timestamp  time.Time
	Price      decimal.Decimal
	Amount     decimal.Decimal
	OrderSide  OrderSide
}

PublicTrade represents a trade made on an exchange. See TradesUpdate and OnTradesUpdate.

type SeqNum ¶

type SeqNum uint32

SeqNum is used to make sure order book deltas are processed in order. Each order book delta update has the sequence number incremented by 1. Sometimes sequence numbers reset to a smaller value (this happens when we deploy or restart our back end for whatever reason). In those cases, the first broadcasted update is a snapshot, so clients should not assume they are out of sync when they receive a snapshot with a lower seq number.

type SparklineUpdate ¶

type SparklineUpdate struct {
	Timestamp time.Time
	Price     decimal.Decimal
}

SparklineUpdate represents the sparkline update for a market at a particular time. A sparkline is a very small line chart, typically drawn without axes or coordinates. It presents the general shape of the variation in price. https://en.wikipedia.org/wiki/Sparkline

type SummaryUpdate ¶

type SummaryUpdate struct {
	Last           decimal.Decimal
	High           decimal.Decimal
	Low            decimal.Decimal
	VolumeBase     decimal.Decimal
	VolumeQuote    decimal.Decimal
	ChangeAbsolute decimal.Decimal
	ChangePercent  decimal.Decimal
	NumTrades      int32
}

SummaryUpdate represents recent summary information for a particular market.

type TradesUpdate ¶

type TradesUpdate struct {
	Trades []PublicTrade
}

TradesUpdate represents the most recent trades that have occurred for a particular market.

type TrendlineUpdate ¶

type TrendlineUpdate struct {
	Window    PerformanceWindow
	Timestamp time.Time
	Price     decimal.Decimal
	Volume    decimal.Decimal
}

TrendlineUpdate represents the trendline update for a market for a particular window. TODO explain calculation

type VWAPUpdate ¶

type VWAPUpdate struct {
	VWAP      decimal.Decimal
	Timestamp time.Time
}

VWAPUpdate represents the most recent volume weighted average price update for a market at a given time. TODO explain calculation