use std::collections::HashMap;
use std::sync::Arc;
use async_trait::async_trait;
use serde::Deserialize;
use crate::book::checksum::{KRAKEN_CHECKSUM_DEPTH, kraken_checksum};
use crate::book::{BookDelta, BookSnapshot, L2Book, LevelChange};
use crate::clock::{Clock, Timestamps, parse_rfc3339_nanos};
use crate::error::{Error, Result};
use crate::fixed::Fixed;
use crate::gap::DetectionLimit;
use crate::limits::VenueBudget;
use crate::sequence::{SeqState, SeqVerdict, Unverifiable};
use crate::symbols::{SymbolMapper, mappers};
use crate::types::{BookLevel, Side, Symbol, VenueId, VenueSymbol};
use crate::venue::{
ControlEvent, ControlKind, DecimalEncoding, FeedDepth, FeedEvent, FeedTransport, HttpFetch,
Keepalive, RawFrame, RedundantDeletes, SequenceScope, SnapshotSource, ValidationScheme,
ValidationTiming, Venue, VenueCapabilities, VenueTimestamps,
};
const WS_URL: &str = "wss://ws.kraken.com/v2";
const REST_ASSET_PAIRS: &str = "https://api.kraken.com/0/public/AssetPairs";
const REST_DEPTH: &str = "https://api.kraken.com/0/public/Depth";
pub const VALID_DEPTHS: &[usize] = &[10, 25, 100, 500, 1000];
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Precision {
pub price: u32,
pub qty: u32,
}
pub struct Kraken {
caps: VenueCapabilities,
http: Arc<dyn HttpFetch>,
clock: Arc<dyn Clock>,
ws_url: String,
depth: usize,
precisions: HashMap<Symbol, Precision>,
symbols: SymbolMapper,
rest_symbols: SymbolMapper,
}
impl Kraken {
pub fn new(http: Arc<dyn HttpFetch>, clock: Arc<dyn Clock>, depth: usize) -> Result<Self> {
if !VALID_DEPTHS.contains(&depth) {
return Err(Error::Other(format!(
"kraken book depth must be one of {VALID_DEPTHS:?}, got {depth}"
)));
}
Ok(Kraken {
caps: Self::capabilities(depth),
http,
clock,
ws_url: WS_URL.to_string(),
depth,
precisions: HashMap::new(),
symbols: mappers::kraken(),
rest_symbols: mappers::kraken_rest(),
})
}
pub fn with_symbols(mut self, symbols: &[Symbol]) -> Self {
self.symbols.register_all(symbols);
self.rest_symbols.register_all(symbols);
self
}
pub fn with_ws_url(mut self, url: impl Into<String>) -> Self {
self.ws_url = url.into();
self
}
pub fn with_precision(mut self, symbol: Symbol, precision: Precision) -> Self {
self.precisions.insert(symbol, precision);
self
}
pub fn precision(&self, symbol: &Symbol) -> Option<Precision> {
self.precisions.get(symbol).copied()
}
pub fn depth(&self) -> usize {
self.depth
}
fn capabilities(depth: usize) -> VenueCapabilities {
let mut detection_limits = vec![DetectionLimit {
venue: VenueId::Kraken,
scope: "always".to_string(),
consequence:
"the feed carries no sequence numbers, so the size of a loss is never known, \
only that one occurred"
.to_string(),
}];
if depth > KRAKEN_CHECKSUM_DEPTH {
detection_limits.push(DetectionLimit {
venue: VenueId::Kraken,
scope: format!("book depth {depth}"),
consequence: format!(
"the venue checksum covers only the {KRAKEN_CHECKSUM_DEPTH} best levels a \
side, so a lost message touching levels {} to {depth} changes the book \
without changing the checksum and is undetectable",
KRAKEN_CHECKSUM_DEPTH + 1
),
});
}
VenueCapabilities {
id: VenueId::Kraken,
book_level: BookLevel::L2,
validation: ValidationScheme::Checksum {
depth: KRAKEN_CHECKSUM_DEPTH,
},
scope: SequenceScope::PerSymbol,
timing: ValidationTiming::AfterApply,
snapshot_source: SnapshotSource::InBand,
feed_depth: FeedDepth::Limited(depth),
decimals: DecimalEncoding::JsonNumbers,
redundant_deletes: RedundantDeletes::Never,
timestamps: VenueTimestamps::PerMessage,
keepalive: Keepalive::ProtocolPings,
budget: VenueBudget {
subscriptions_per_connection: 50,
max_connections: 4,
connect_interval: std::time::Duration::from_secs(1),
connect_burst: 2,
rest_interval: std::time::Duration::from_secs(1),
rest_burst: 2,
},
requires_auth: false,
detection_limits,
}
}
fn from_kraken_asset(asset: &str) -> &str {
match asset {
"XBT" => "BTC",
"XDG" => "DOGE",
other => other,
}
}
fn rest_pair(&self, symbol: &Symbol) -> String {
self.rest_symbols.to_venue(symbol).0
}
pub async fn load_precisions(&mut self, symbols: &[Symbol]) -> Result<()> {
let body = self.http.get(REST_ASSET_PAIRS).await?;
let parsed: AssetPairsResponse = serde_json::from_slice(&body)
.map_err(|e| Error::protocol(VenueId::Kraken, format!("AssetPairs: {e}"), &body))?;
if let Some(first) = parsed.error.first() {
return Err(Error::protocol(
VenueId::Kraken,
format!("AssetPairs returned {first}"),
&body,
));
}
let mut by_symbol: HashMap<Symbol, Precision> = HashMap::new();
for pair in parsed.result.values() {
let Some(wsname) = &pair.wsname else { continue };
let Ok(symbol) = Kraken::canonical_from_slash(wsname) else {
continue;
};
by_symbol.insert(
symbol,
Precision {
price: pair.pair_decimals,
qty: pair.lot_decimals,
},
);
}
for symbol in symbols {
match by_symbol.get(symbol) {
Some(p) => {
self.precisions.insert(symbol.clone(), *p);
}
None => {
return Err(Error::UnknownSymbol {
venue: VenueId::Kraken,
symbol: symbol.to_string(),
});
}
}
}
Ok(())
}
fn canonical_from_slash(raw: &str) -> Result<Symbol> {
let symbol = Symbol::parse(raw).map_err(|_| Error::UnknownSymbol {
venue: VenueId::Kraken,
symbol: raw.to_string(),
})?;
Ok(Symbol::new(
Kraken::from_kraken_asset(symbol.base()),
Kraken::from_kraken_asset(symbol.quote()),
))
}
fn levels(entries: &[BookLevelJson], side: Side) -> Vec<LevelChange> {
entries
.iter()
.map(|l| LevelChange::new(side, l.price, l.qty))
.collect()
}
}
#[derive(Debug, Deserialize)]
struct AssetPairsResponse {
#[serde(default)]
error: Vec<String>,
#[serde(default)]
result: HashMap<String, AssetPair>,
}
#[derive(Debug, Deserialize)]
struct AssetPair {
wsname: Option<String>,
pair_decimals: u32,
lot_decimals: u32,
}
#[derive(Debug, Deserialize)]
struct DepthResponse {
#[serde(default)]
error: Vec<String>,
#[serde(default)]
result: HashMap<String, DepthBook>,
}
#[derive(Debug, Deserialize)]
struct DepthBook {
#[serde(default)]
asks: Vec<DepthLevel>,
#[serde(default)]
bids: Vec<DepthLevel>,
}
#[derive(Debug, Deserialize)]
struct DepthLevel(Fixed, Fixed, #[allow(dead_code)] serde_json::Value);
#[derive(Debug, Deserialize)]
struct Frame {
channel: Option<String>,
#[serde(rename = "type")]
kind: Option<String>,
#[serde(default)]
data: Vec<serde_json::Value>,
method: Option<String>,
success: Option<bool>,
error: Option<String>,
}
#[derive(Debug, Deserialize)]
struct BookData {
symbol: String,
#[serde(default)]
bids: Vec<BookLevelJson>,
#[serde(default)]
asks: Vec<BookLevelJson>,
checksum: Option<u32>,
timestamp: Option<String>,
}
#[derive(Debug, Deserialize)]
struct BookLevelJson {
price: Fixed,
qty: Fixed,
}
#[async_trait]
impl Venue for Kraken {
fn capabilities(&self) -> &VenueCapabilities {
&self.caps
}
fn venue_symbol(&self, symbol: &Symbol) -> VenueSymbol {
self.symbols.to_venue(symbol)
}
fn canonical_symbol(&self, raw: &str) -> Result<Symbol> {
Kraken::canonical_from_slash(raw)
}
async fn connect(&self) -> Result<Box<dyn FeedTransport>> {
let transport = crate::transport::WsTransport::connect(
VenueId::Kraken,
&self.ws_url,
Arc::clone(&self.clock),
)
.await?;
Ok(Box::new(transport))
}
fn subscribe(&self, symbols: &[Symbol]) -> Result<Vec<String>> {
if symbols.is_empty() {
return Err(Error::Subscription {
venue: VenueId::Kraken,
reason: "no symbols requested".to_string(),
});
}
let names: Vec<String> = symbols.iter().map(|s| self.venue_symbol(s).0).collect();
Ok(vec![
serde_json::json!({
"method": "subscribe",
"params": {
"channel": "book",
"symbol": names,
"depth": self.depth,
"snapshot": true,
},
})
.to_string(),
])
}
async fn snapshot(&self, symbol: &Symbol) -> Result<BookSnapshot> {
let url = format!(
"{REST_DEPTH}?pair={}&count={}",
self.rest_pair(symbol),
self.depth
);
let body = self.http.get(&url).await?;
let parsed: DepthResponse = serde_json::from_slice(&body)
.map_err(|e| Error::protocol(VenueId::Kraken, format!("Depth: {e}"), &body))?;
if let Some(first) = parsed.error.first() {
return Err(Error::protocol(
VenueId::Kraken,
format!("Depth returned {first}"),
&body,
));
}
let book = parsed
.result
.values()
.next()
.ok_or_else(|| Error::protocol(VenueId::Kraken, "Depth returned no pair", &body))?;
Ok(BookSnapshot {
symbol: symbol.clone(),
bids: book.bids.iter().map(|l| (l.0, l.1)).collect(),
asks: book.asks.iter().map(|l| (l.0, l.1)).collect(),
seq: None,
checksum: None,
stamps: Timestamps::recv_only(self.clock.stamp()),
})
}
fn parse_delta(&self, frame: &RawFrame) -> Result<Vec<FeedEvent>> {
let parsed: Frame = serde_json::from_slice(&frame.payload)
.map_err(|e| Error::protocol(VenueId::Kraken, e.to_string(), &frame.payload))?;
if parsed.method.is_some() {
let ok = parsed.success.unwrap_or(false);
return Ok(vec![FeedEvent::Control(ControlEvent {
kind: if ok {
ControlKind::SubscriptionAck
} else {
ControlKind::SubscriptionError
},
detail: parsed
.error
.unwrap_or_else(|| parsed.method.unwrap_or_default()),
stamp: frame.stamp,
seq: None,
})]);
}
let channel = parsed.channel.as_deref().unwrap_or("");
if channel != "book" {
let kind = match channel {
"heartbeat" => ControlKind::Heartbeat,
"status" => ControlKind::Status,
"" => ControlKind::Ignored,
_ => ControlKind::Status,
};
return Ok(vec![FeedEvent::Control(ControlEvent {
kind,
detail: channel.to_string(),
stamp: frame.stamp,
seq: None,
})]);
}
let is_snapshot = match parsed.kind.as_deref() {
Some("snapshot") => true,
Some("update") => false,
other => {
return Err(Error::protocol(
VenueId::Kraken,
format!("unknown book message type {other:?}"),
&frame.payload,
));
}
};
let mut out = Vec::with_capacity(parsed.data.len());
for value in parsed.data {
let data: BookData = serde_json::from_value(value).map_err(|e| {
Error::protocol(VenueId::Kraken, format!("book data: {e}"), &frame.payload)
})?;
let symbol = self.canonical_symbol(&data.symbol)?;
let stamps = Timestamps::new(
frame.stamp,
data.timestamp.as_deref().and_then(parse_rfc3339_nanos),
);
if is_snapshot {
out.push(FeedEvent::Snapshot(BookSnapshot {
symbol,
bids: data.bids.iter().map(|l| (l.price, l.qty)).collect(),
asks: data.asks.iter().map(|l| (l.price, l.qty)).collect(),
seq: None,
checksum: data.checksum,
stamps,
}));
} else {
let mut changes = Kraken::levels(&data.bids, Side::Bid);
changes.extend(Kraken::levels(&data.asks, Side::Ask));
out.push(FeedEvent::Delta(BookDelta {
symbol,
changes,
seq: None,
checksum: data.checksum,
stamps,
prev_seq: None,
first_seq: None,
}));
}
}
Ok(out)
}
fn validate_sequence(
&self,
state: &mut SeqState,
event: &FeedEvent,
book: &L2Book,
) -> SeqVerdict {
let SeqState::Checksum(checksum_state) = state else {
return SeqVerdict::Unverifiable(Unverifiable::VenuePublishesNoSequence);
};
let (symbol, expected) = match event {
FeedEvent::Snapshot(s) => (&s.symbol, s.checksum),
FeedEvent::Delta(d) => (&d.symbol, d.checksum),
FeedEvent::Order(_) | FeedEvent::Control(_) => {
return SeqVerdict::Unverifiable(Unverifiable::MessageCarriedNoCheck);
}
};
let Some(expected) = expected else {
return SeqVerdict::Unverifiable(Unverifiable::MessageCarriedNoCheck);
};
let Some(precision) = self.precision(symbol) else {
return SeqVerdict::Unverifiable(Unverifiable::MissingInstrumentMetadata);
};
let computed = kraken_checksum(book, precision.price, precision.qty);
checksum_state.observe(expected, computed)
}
}