use crc32fast::Hasher;
use super::L2Book;
use crate::fixed::Fixed;
use crate::types::Side;
pub const KRAKEN_CHECKSUM_DEPTH: usize = 10;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ChecksumResult {
pub value: u32,
pub lossy_levels: usize,
pub bid_levels: usize,
pub ask_levels: usize,
}
impl ChecksumResult {
pub fn is_trustworthy(&self) -> bool {
self.lossy_levels == 0
&& self.bid_levels == KRAKEN_CHECKSUM_DEPTH
&& self.ask_levels == KRAKEN_CHECKSUM_DEPTH
}
}
fn checksum_token(value: Fixed, precision: u32, lossy: &mut usize) -> String {
if !value.fits(precision) {
*lossy += 1;
}
let rendered = value.to_decimal_string(precision);
let digits: String = rendered.chars().filter(|c| c.is_ascii_digit()).collect();
let trimmed = digits.trim_start_matches('0');
if trimmed.is_empty() {
"0".to_string()
} else {
trimmed.to_string()
}
}
pub fn kraken_checksum(book: &L2Book, price_precision: u32, qty_precision: u32) -> ChecksumResult {
let asks = book.top(Side::Ask, KRAKEN_CHECKSUM_DEPTH);
let bids = book.top(Side::Bid, KRAKEN_CHECKSUM_DEPTH);
let mut lossy_levels = 0;
let mut buf = String::with_capacity(KRAKEN_CHECKSUM_DEPTH * 4 * 12);
for (price, qty) in &asks {
buf.push_str(&checksum_token(*price, price_precision, &mut lossy_levels));
buf.push_str(&checksum_token(*qty, qty_precision, &mut lossy_levels));
}
for (price, qty) in &bids {
buf.push_str(&checksum_token(*price, price_precision, &mut lossy_levels));
buf.push_str(&checksum_token(*qty, qty_precision, &mut lossy_levels));
}
let mut hasher = Hasher::new();
hasher.update(buf.as_bytes());
ChecksumResult {
value: hasher.finalize(),
lossy_levels,
bid_levels: bids.len(),
ask_levels: asks.len(),
}
}
pub fn book_digest(book: &L2Book) -> u32 {
let mut hasher = Hasher::new();
hasher.update(book.symbol().as_str().as_bytes());
for (side, tag) in [(Side::Bid, b'B'), (Side::Ask, b'A')] {
hasher.update(&[tag]);
for (price, qty) in book.top(side, usize::MAX) {
hasher.update(price.mantissa().to_le_bytes().as_slice());
hasher.update(qty.mantissa().to_le_bytes().as_slice());
}
}
hasher.finalize()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::book::BookSnapshot;
use crate::clock::{Stamp, Timestamps};
use crate::types::Symbol;
fn f(s: &str) -> Fixed {
Fixed::from_decimal_str(s).unwrap()
}
fn stamps() -> Timestamps {
Timestamps::recv_only(Stamp::ZERO)
}
fn ten_deep() -> L2Book {
let symbol = Symbol::new("BTC", "USD");
let mut book = L2Book::new(symbol.clone());
let bids: Vec<(Fixed, Fixed)> = (0..10)
.map(|i| (f(&format!("{}.1", 100 - i)), f("0.5")))
.collect();
let asks: Vec<(Fixed, Fixed)> = (0..10)
.map(|i| (f(&format!("{}.1", 101 + i)), f("0.5")))
.collect();
book.reset_from_snapshot(&BookSnapshot {
symbol,
bids,
asks,
seq: None,
checksum: None,
stamps: stamps(),
});
book
}
#[test]
fn token_strips_the_point_and_leading_zeros() {
let mut lossy = 0;
assert_eq!(checksum_token(f("0.00234"), 8, &mut lossy), "234000");
assert_eq!(checksum_token(f("50000.1"), 1, &mut lossy), "500001");
assert_eq!(checksum_token(f("1"), 0, &mut lossy), "1");
assert_eq!(lossy, 0);
}
#[test]
fn token_of_zero_is_a_single_zero_not_an_empty_string() {
let mut lossy = 0;
assert_eq!(checksum_token(f("0"), 8, &mut lossy), "0");
assert_eq!(lossy, 0);
}
#[test]
fn rendering_that_loses_digits_is_counted_not_hidden() {
let mut lossy = 0;
let token = checksum_token(f("0.005"), 2, &mut lossy);
assert_eq!(lossy, 1);
assert_eq!(token, "1"); }
#[test]
fn checksum_is_deterministic_and_precision_sensitive() {
let book = ten_deep();
let a = kraken_checksum(&book, 1, 8);
let b = kraken_checksum(&book, 1, 8);
assert_eq!(a, b);
assert!(a.is_trustworthy());
assert_ne!(a.value, kraken_checksum(&book, 2, 8).value);
}
#[test]
fn checksum_changes_when_any_hashed_level_changes() {
let mut book = ten_deep();
let before = kraken_checksum(&book, 1, 8).value;
let mut outcome = Default::default();
book.apply_change(
crate::book::LevelChange::new(Side::Bid, f("100.1"), f("0.6")),
&mut outcome,
);
assert_ne!(before, kraken_checksum(&book, 1, 8).value);
}
#[test]
fn a_shallow_book_is_not_trustworthy_for_checksum_validation() {
let symbol = Symbol::new("BTC", "USD");
let mut book = L2Book::new(symbol.clone());
book.reset_from_snapshot(&BookSnapshot {
symbol,
bids: vec![(f("99"), f("1"))],
asks: vec![(f("101"), f("1"))],
seq: None,
checksum: None,
stamps: stamps(),
});
let result = kraken_checksum(&book, 1, 8);
assert!(!result.is_trustworthy());
assert_eq!(result.bid_levels, 1);
}
#[test]
fn side_order_matters_asks_are_hashed_before_bids() {
let symbol = Symbol::new("X", "Y");
let mut book = L2Book::new(symbol.clone());
book.reset_from_snapshot(&BookSnapshot {
symbol,
bids: vec![(f("1"), f("2"))],
asks: vec![(f("3"), f("4"))],
seq: None,
checksum: None,
stamps: stamps(),
});
let mut expected = Hasher::new();
expected.update(b"3412"); assert_eq!(kraken_checksum(&book, 0, 0).value, expected.finalize());
}
#[test]
fn digest_covers_full_depth_not_just_the_top_ten() {
let mut a = ten_deep();
let mut b = ten_deep();
let mut outcome = Default::default();
a.apply_change(
crate::book::LevelChange::new(Side::Bid, f("1"), f("1")),
&mut outcome,
);
assert_ne!(a.digest(), b.digest());
b.apply_change(
crate::book::LevelChange::new(Side::Bid, f("1"), f("1")),
&mut outcome,
);
assert_eq!(a.digest(), b.digest());
}
#[test]
fn kraken_checksum_ignores_levels_past_the_tenth() {
let mut book = ten_deep();
let before = kraken_checksum(&book, 1, 8).value;
let mut outcome = Default::default();
book.apply_change(
crate::book::LevelChange::new(Side::Bid, f("50"), f("1")),
&mut outcome,
);
assert_eq!(before, kraken_checksum(&book, 1, 8).value);
assert_ne!(book.digest(), ten_deep().digest());
}
}