use color_eyre::Result;
use rust_decimal::Decimal;
use serde::Deserialize;
use crate::{
ports::{MarketDataSource, PortError},
proto::{common, market},
};
#[derive(Debug, Clone, Deserialize)]
pub struct CommonParams {
#[serde(default = "default_exchange")]
pub exchange_id: String,
#[serde(default)]
pub label: String,
pub symbol: String,
#[serde(default = "default_timeframe")]
pub timeframe: String,
#[serde(default = "default_poll_secs")]
pub poll_secs: u64,
}
#[derive(Debug, Clone, Deserialize)]
pub struct VenueRef {
#[serde(default = "default_exchange")]
pub exchange_id: String,
#[serde(default)]
pub label: String,
}
impl VenueRef {
#[must_use]
pub fn proto(&self) -> common::ExchangeId {
crate::ports::exchange_id(&self.exchange_id, &self.label)
}
}
#[derive(Debug, Clone, Deserialize)]
pub struct CrossVenueParams {
pub primary: VenueRef,
pub hedge: VenueRef,
pub symbol: String,
#[serde(default = "default_poll_secs")]
pub poll_secs: u64,
}
impl CrossVenueParams {
pub fn from_params(table: &toml::Table) -> Result<Self> {
params_from_table(table)
}
}
pub(crate) const fn default_poll_secs() -> u64 {
30
}
fn default_timeframe() -> String {
String::from("5m")
}
fn default_exchange() -> String {
String::from("mock")
}
impl CommonParams {
#[must_use]
pub fn proto_exchange_id(&self) -> common::ExchangeId {
crate::ports::exchange_id(&self.exchange_id, &self.label)
}
}
pub fn params_from_table<T: serde::de::DeserializeOwned>(table: &toml::Table) -> Result<T> {
toml::Value::Table(table.clone())
.try_into()
.map_err(|err| color_eyre::eyre::eyre!("invalid strategy params: {err}"))
}
pub(crate) fn timeframe_from_str(tf: &str) -> Result<market::Timeframe, PortError> {
let normalized = tf.trim().to_ascii_uppercase();
if normalized.is_empty() {
return Err(PortError::InvalidArgument(
"unsupported timeframe \"\" (supported: S1/S100/M1/M5/M15/M30/H1/H4/D1/W1)".to_string(),
));
}
Ok(match normalized.as_str() {
"1M" | "M1" => market::Timeframe::M1,
"5M" | "M5" => market::Timeframe::M5,
"15M" | "M15" => market::Timeframe::M15,
"30M" | "M30" => market::Timeframe::M30,
"1H" | "H1" => market::Timeframe::H1,
"4H" | "H4" => market::Timeframe::H4,
"1D" | "D1" => market::Timeframe::D1,
"1W" | "W1" => market::Timeframe::W1,
"1S" | "S1" => market::Timeframe::S1,
"100S" | "S100" => market::Timeframe::S100,
other => {
return Err(PortError::InvalidArgument(format!(
"unsupported timeframe {other:?} (supported: S1/S100/M1/M5/M15/M30/H1/H4/D1/W1)"
)));
}
})
}
pub(crate) async fn fetch_candles(
market: &dyn MarketDataSource,
exchange_id: &common::ExchangeId,
symbol: &str,
timeframe: &str,
limit: u32,
) -> Result<Vec<market::Candle>, PortError> {
let response = market
.get_candles(market::GetCandlesRequest {
exchange_id: buffa::MessageField::some(exchange_id.clone()),
symbol: symbol.to_string(),
timeframe: buffa::EnumValue::Known(timeframe_from_str(timeframe)?),
pagination: crate::proto::common::Pagination {
limit: u64::from(limit),
..Default::default()
}
.into(),
..Default::default()
})
.await?;
Ok(response.candles)
}
pub(crate) fn closes_of(candles: &[market::Candle]) -> Vec<Decimal> {
candles
.iter()
.filter_map(|c| c.close.as_option())
.filter_map(|d| longtrader_contract::ext::common_to_decimal(d).ok())
.collect()
}
pub(crate) async fn fetch_closes_of(
market: &dyn MarketDataSource,
exchange_id: &common::ExchangeId,
symbol: &str,
timeframe: &str,
) -> Result<Vec<Decimal>, PortError> {
let candles = fetch_candles(market, exchange_id, symbol, timeframe, 200).await?;
Ok(closes_of(&candles))
}
#[cfg(test)]
mod tests {
use proptest::prelude::*;
use rust_decimal_macros::dec;
use super::*;
#[test]
fn every_documented_timeframe_spelling_is_accepted() {
let cases = [
("1m", market::Timeframe::M1),
("M1", market::Timeframe::M1),
("5m", market::Timeframe::M5),
("M5", market::Timeframe::M5),
("15m", market::Timeframe::M15),
("M15", market::Timeframe::M15),
("30m", market::Timeframe::M30),
("M30", market::Timeframe::M30),
("1h", market::Timeframe::H1),
("H1", market::Timeframe::H1),
("4h", market::Timeframe::H4),
("H4", market::Timeframe::H4),
("1d", market::Timeframe::D1),
("D1", market::Timeframe::D1),
("1w", market::Timeframe::W1),
("W1", market::Timeframe::W1),
("1s", market::Timeframe::S1),
("S1", market::Timeframe::S1),
("100s", market::Timeframe::S100),
("S100", market::Timeframe::S100),
];
for (input, expected) in cases {
assert_eq!(
timeframe_from_str(input).expect("documented spelling"),
expected,
"timeframe {input:?}"
);
}
}
#[test]
fn the_timeframe_parser_ignores_case_and_surrounding_space() {
for input in ["m5", "M5", "m5 ", " m5", " m5\t"] {
assert_eq!(
timeframe_from_str(input).expect("case/space insensitive"),
market::Timeframe::M5,
"{input:?}"
);
}
}
#[test]
fn an_unsupported_timeframe_is_an_error_not_a_default() {
for input in ["", " ", "2m", "M2", "1x", "hourly", "5", "m", "-5m", "M0", "S2", "999m"] {
let err = timeframe_from_str(input).expect_err("must not silently default");
assert!(matches!(err, PortError::InvalidArgument(_)), "{input:?} produced {err:?}");
let message = err.to_string();
assert!(
message.contains("unsupported timeframe"),
"the message must say what went wrong: {message}"
);
}
}
#[test]
fn the_timeframe_error_lists_the_supported_periods() {
let err = timeframe_from_str("2m").expect_err("unsupported");
let message = err.to_string();
for supported in ["S1", "S100", "M1", "M5", "M15", "M30", "H1", "H4", "D1", "W1"] {
assert!(message.contains(supported), "the error must mention {supported}: {message}");
}
}
#[test]
fn the_timeframe_error_echoes_the_normalized_input() {
let err = timeframe_from_str(" bogus ").expect_err("unsupported");
assert!(err.to_string().contains("BOGUS"), "{err}");
}
fn table(doc: &str) -> toml::Table {
let value: toml::Value = toml::from_str(doc).expect("the fixture parses");
match value {
toml::Value::Table(table) => table,
_ => unreachable!("the fixture is always a table"),
}
}
#[test]
fn common_params_apply_every_documented_default() {
let params: CommonParams = params_from_table(&table("symbol = \"BTC/USDT\""))
.expect("only the symbol is required");
assert_eq!(params.symbol, "BTC/USDT");
assert_eq!(params.exchange_id, "mock", "the default venue is the mock backend");
assert_eq!(params.label, "");
assert_eq!(params.timeframe, "5m");
assert_eq!(params.poll_secs, 30);
}
#[test]
fn common_params_require_a_symbol() {
let err = params_from_table::<CommonParams>(&table("exchange_id = \"binance\""))
.expect_err("symbol is required");
assert!(err.to_string().contains("symbol"), "{err}");
}
#[test]
fn every_common_param_can_be_overridden() {
let params: CommonParams = params_from_table(&table(
"symbol = \"ETH/USDT\"\nexchange_id = \"htx\"\nlabel = \"sub\"\ntimeframe = \"1h\"\npoll_secs = 7\n",
))
.expect("all fields supplied");
assert_eq!(params.symbol, "ETH/USDT");
assert_eq!(params.exchange_id, "htx");
assert_eq!(params.label, "sub");
assert_eq!(params.timeframe, "1h");
assert_eq!(params.poll_secs, 7);
}
#[test]
fn common_params_build_the_proto_exchange_id() {
let params: CommonParams = params_from_table(&table(
"symbol = \"X\"\nexchange_id = \"binance\"\nlabel = \"sub-2\"\n",
))
.expect("parses");
let id = params.proto_exchange_id();
assert_eq!(id.id, "binance");
assert_eq!(id.label, "sub-2");
}
#[test]
fn venue_ref_applies_its_defaults_and_builds_its_proto() {
let params: VenueRef =
params_from_table(&table("exchange_id = \"okx\"\nlabel = \"acct\"")).expect("parses");
assert_eq!(params.exchange_id, "okx");
let id = params.proto();
assert_eq!(id.id, "okx");
assert_eq!(id.label, "acct");
let bare: VenueRef = params_from_table(&table("")).expect("all fields optional");
assert_eq!(bare.exchange_id, "mock");
assert_eq!(bare.label, "");
}
#[test]
fn cross_venue_params_require_both_legs() {
let err = params_from_table::<CrossVenueParams>(&table(
"symbol = \"X\"\n[primary]\nexchange_id = \"a\"\n",
))
.expect_err("hedge is required");
assert!(err.to_string().contains("hedge"), "{err}");
let params: CrossVenueParams = params_from_table(&table(
"symbol = \"X\"\n[primary]\nexchange_id = \"a\"\n[hedge]\nexchange_id = \"b\"\n",
))
.expect("both legs present");
assert_eq!(params.primary.exchange_id, "a");
assert_eq!(params.hedge.exchange_id, "b");
assert_eq!(params.poll_secs, 30);
}
#[test]
fn cross_venue_params_round_trip_through_from_params() {
let table =
table("symbol = \"X\"\n[primary]\nexchange_id = \"a\"\n[hedge]\nexchange_id = \"b\"\n");
let params = CrossVenueParams::from_params(&table).expect("parses");
assert_eq!(params.symbol, "X");
}
#[test]
fn a_wrongly_typed_param_is_rejected() {
let err = params_from_table::<CommonParams>(&table("symbol = 42")).expect_err("type error");
assert!(err.to_string().contains("symbol"), "{err}");
let err = params_from_table::<CommonParams>(&table("symbol = \"X\"\npoll_secs = \"soon\""))
.expect_err("type error");
assert!(err.to_string().contains("poll_secs"), "{err}");
}
#[test]
fn param_errors_are_namespaced() {
let err = params_from_table::<CommonParams>(&table("")).expect_err("missing symbol");
assert!(err.to_string().contains("invalid strategy params"), "{err}");
}
fn candle_with_close(close: Option<Decimal>) -> market::Candle {
market::Candle {
close: close
.map(longtrader_contract::ext::decimal_to_common)
.map_or_default(buffa::MessageField::some),
..Default::default()
}
}
fn candle_with_wire_close(value: &str) -> market::Candle {
market::Candle {
close: buffa::MessageField::some(common::Decimal {
value: value.to_string(),
..Default::default()
}),
..Default::default()
}
}
#[test]
fn closes_of_extracts_every_decodable_close() {
let candles = vec![
candle_with_close(Some(dec!(1.5))),
candle_with_close(Some(dec!(2.5))),
candle_with_close(Some(dec!(3.5))),
];
assert_eq!(closes_of(&candles), vec![dec!(1.5), dec!(2.5), dec!(3.5)]);
}
#[test]
fn closes_of_skips_candles_without_a_close() {
let candles = vec![
candle_with_close(Some(dec!(1))),
candle_with_close(None),
candle_with_close(Some(dec!(3))),
];
assert_eq!(closes_of(&candles), vec![dec!(1), dec!(3)]);
}
#[test]
fn closes_of_skips_undecodable_decimals() {
let candles = vec![
candle_with_close(Some(dec!(7))),
candle_with_wire_close(""),
candle_with_wire_close("1e3"),
candle_with_wire_close(" 1"),
candle_with_wire_close(&"9".repeat(29)),
];
assert_eq!(closes_of(&candles), vec![dec!(7)]);
}
#[test]
fn closes_of_drops_a_payload_outside_the_contract_grammar() {
for garbage in ["not-a-number", "1_000", "+1", ".5", "1."] {
assert!(
closes_of(&[candle_with_wire_close(garbage)]).is_empty(),
"{garbage:?} is not a close price"
);
}
}
#[test]
fn closes_of_an_empty_window_is_empty() {
assert!(closes_of(&[]).is_empty());
}
#[test]
fn closes_of_an_all_unusable_window_is_empty() {
let candles = vec![candle_with_close(None), candle_with_close(None)];
assert!(closes_of(&candles).is_empty());
}
proptest! {
#![proptest_config(ProptestConfig::with_cases(256))]
#[test]
fn the_timeframe_parser_normalizes_case_and_space(
base in prop::sample::select(&["1m", "M1", "5m", "M5", "15m", "30m", "1h", "4h", "1d", "1w", "1s", "100s"]),
pad_left in 0usize..4,
pad_right in 0usize..4,
) {
let expected = timeframe_from_str(base).expect("documented spelling");
let padded = format!("{}{base}{}", " ".repeat(pad_left), " ".repeat(pad_right));
prop_assert_eq!(timeframe_from_str(&padded).expect("normalizes"), expected);
prop_assert_eq!(timeframe_from_str(&base.to_uppercase()).expect("normalizes"), expected);
prop_assert_eq!(timeframe_from_str(&base.to_lowercase()).expect("normalizes"), expected);
}
#[test]
fn an_undocumented_timeframe_always_errors(input in "[a-zA-Z0-9]{1,6}") {
let documented = [
"1M", "M1", "5M", "M5", "15M", "M15", "30M", "M30", "1H", "H1", "4H", "H4",
"1D", "D1", "1W", "W1", "1S", "S1", "100S", "S100",
];
let normalized = input.trim().to_ascii_uppercase();
if documented.contains(&normalized.as_str()) {
return Ok(());
}
prop_assert!(
matches!(timeframe_from_str(&input), Err(PortError::InvalidArgument(_))),
"{input:?} must not resolve"
);
}
#[test]
fn closes_of_never_drops_a_well_formed_close(
values in prop::collection::vec(-1_000_000i64..1_000_000, 0..20),
) {
let candles: Vec<market::Candle> = values
.into_iter()
.map(|v| candle_with_close(Some(Decimal::from(v))))
.collect();
let closes = closes_of(&candles);
prop_assert_eq!(closes.len(), candles.len());
}
#[test]
fn the_proto_exchange_id_never_transforms_the_venue(
venue in "[a-z0-9_-]{1,12}",
label in "[a-z0-9_-]{0,12}",
) {
let params: CommonParams = params_from_table(&table(&format!(
"symbol = \"X\"\nexchange_id = \"{venue}\"\nlabel = \"{label}\"\n"
)))
.expect("the generated table parses");
let id = params.proto_exchange_id();
prop_assert_eq!(id.id.as_str(), venue.as_str());
prop_assert_eq!(id.label.as_str(), label.as_str());
}
}
}