use std::{collections::VecDeque, sync::Arc};
use async_trait::async_trait;
use color_eyre::Result;
use rust_decimal::Decimal;
use serde::Deserialize;
use tokio::sync::Mutex;
use crate::{
ports::{MarketDataSource, TradingGateway},
strategies::{CommonParams, Strategy, fetch_candles, market_order, params_from_table},
};
#[derive(Debug, Clone, Deserialize)]
pub struct IchimokuConfig {
#[serde(flatten)]
pub common: CommonParams,
#[serde(default = "default_tenkan")]
pub tenkan_period: usize,
#[serde(default = "default_kijun")]
pub kijun_period: usize,
#[serde(default = "default_senkou_b")]
pub senkou_b_period: usize,
#[serde(default = "default_qty")]
pub qty: Decimal,
}
const fn default_tenkan() -> usize {
9
}
const fn default_kijun() -> usize {
26
}
const fn default_senkou_b() -> usize {
52
}
fn default_qty() -> Decimal {
Decimal::new(1, 3)
}
impl IchimokuConfig {
pub fn from_params(table: &toml::Table) -> Result<Self> {
params_from_table(table)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Phase {
Flat,
Long,
Short,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Signal {
Enter(bool),
Exit,
}
impl Phase {
const fn exit_side(self) -> bool {
matches!(self, Self::Short)
}
}
pub struct Ichimoku {
config: IchimokuConfig,
gateway: Arc<dyn TradingGateway>,
market: Arc<dyn MarketDataSource>,
phase: Mutex<Phase>,
}
impl Ichimoku {
pub fn new(
config: IchimokuConfig,
gateway: Arc<dyn TradingGateway>,
market: Arc<dyn MarketDataSource>,
) -> Self {
Self { config, gateway, market, phase: Mutex::new(Phase::Flat) }
}
fn window_extremes(
bars: &VecDeque<(Decimal, Decimal)>,
window: usize,
) -> Option<(Decimal, Decimal)> {
let n = bars.len();
if n < window {
return None;
}
let mut hi = Decimal::MIN;
let mut lo = Decimal::MAX;
for (h, l) in bars.iter().skip(n - window).take(window) {
if *h > hi {
hi = *h;
}
if *l < lo {
lo = *l;
}
}
Some((hi, lo))
}
fn line_value(bars: &VecDeque<(Decimal, Decimal)>, window: usize) -> Option<Decimal> {
let (hi, lo) = Self::window_extremes(bars, window)?;
Some((hi + lo) / Decimal::from(2))
}
pub async fn tick(&self) -> Result<()> {
let exchange = self.config.common.proto_exchange_id();
let need = self.config.senkou_b_period + self.config.kijun_period + 10;
let candles = fetch_candles(
self.market.as_ref(),
&exchange,
&self.config.common.symbol,
&self.config.common.timeframe,
need as u32,
)
.await?;
let mut bars = VecDeque::with_capacity(need);
let mut closes = Vec::with_capacity(candles.len());
for candle in &candles {
let (Some(h), Some(l), Some(c)) =
(candle.high.as_option(), candle.low.as_option(), candle.close.as_option())
else {
continue;
};
let (Ok(h), Ok(l), Ok(c)) = (
longtrader_contract::ext::common_to_decimal(h),
longtrader_contract::ext::common_to_decimal(l),
longtrader_contract::ext::common_to_decimal(c),
) else {
continue;
};
bars.push_back((h, l));
closes.push(c);
}
let n = bars.len();
if n < self.config.senkou_b_period + self.config.kijun_period {
tracing::debug!("ichimoku warmup incomplete: {n} bars");
return Ok(());
}
let tenkan = match Self::line_value(&bars, self.config.tenkan_period) {
Some(v) => v,
None => return Ok(()),
};
let kijun = match Self::line_value(&bars, self.config.kijun_period) {
Some(v) => v,
None => return Ok(()),
};
let senkou_src = n - self.config.kijun_period;
let mut sub = VecDeque::with_capacity(self.config.senkou_b_period);
for item in bars
.iter()
.skip(senkou_src.saturating_sub(self.config.senkou_b_period))
.take(self.config.senkou_b_period)
{
sub.push_back(*item);
}
let senkou_b = Self::line_value(&sub, self.config.senkou_b_period)
.expect("sub-window covers senkou_b_period");
let tenkan_src = if senkou_src >= self.config.tenkan_period {
let mut s = VecDeque::with_capacity(self.config.tenkan_period);
for item in bars
.iter()
.skip(senkou_src - self.config.tenkan_period)
.take(self.config.tenkan_period)
{
s.push_back(*item);
}
Self::line_value(&s, self.config.tenkan_period).unwrap_or(tenkan)
} else {
tenkan
};
let kijun_src = if senkou_src >= self.config.kijun_period {
let mut s = VecDeque::with_capacity(self.config.kijun_period);
for item in bars
.iter()
.skip(senkou_src - self.config.kijun_period)
.take(self.config.kijun_period)
{
s.push_back(*item);
}
Self::line_value(&s, self.config.kijun_period).unwrap_or(kijun)
} else {
kijun
};
let senkou_a = (tenkan_src + kijun_src) / Decimal::from(2);
let close = *closes.last().expect("non-empty");
let cloud_top = senkou_a.max(senkou_b);
let cloud_bottom = senkou_a.min(senkou_b);
let price_above_cloud = close > cloud_top;
let price_below_cloud = close < cloud_bottom;
let price_in_cloud = !price_above_cloud && !price_below_cloud;
let cloud_bullish = senkou_a > senkou_b;
let held = *self.phase.lock().await;
let signal = match held {
Phase::Flat => {
if tenkan > kijun && price_above_cloud && cloud_bullish {
Signal::Enter(true)
} else if tenkan < kijun && price_below_cloud && !cloud_bullish {
Signal::Enter(false)
} else {
return Ok(());
}
}
Phase::Long => {
if price_in_cloud || tenkan < kijun {
Signal::Exit
} else {
return Ok(());
}
}
Phase::Short => {
if price_in_cloud || tenkan > kijun {
Signal::Exit
} else {
return Ok(());
}
}
};
let is_buy = match signal {
Signal::Enter(is_buy) => is_buy,
Signal::Exit => held.exit_side(),
};
let coid = format!("ichi-{}", ulid::Ulid::generate());
self.gateway
.create_order(market_order(
&exchange,
&self.config.common.symbol,
coid,
is_buy,
self.config.qty,
))
.await?;
match signal {
Signal::Enter(is_buy) if is_buy => *self.phase.lock().await = Phase::Long,
Signal::Enter(_) => *self.phase.lock().await = Phase::Short,
Signal::Exit => *self.phase.lock().await = Phase::Flat,
}
tracing::info!(side = if is_buy { "buy" } else { "sell" }, %tenkan, %kijun, "ichimoku signal traded");
Ok(())
}
}
#[async_trait]
impl Strategy for Ichimoku {
async fn run(&self) -> Result<()> {
let poll = std::time::Duration::from_secs(self.config.common.poll_secs.max(1));
loop {
if let Err(err) = self.tick().await {
tracing::error!(error = %err, "ichimoku tick failed");
}
tokio::time::sleep(poll).await;
}
}
}
#[cfg(test)]
mod tests {
use std::sync::{Arc as StdArc, Mutex as StdMutex};
use async_trait::async_trait;
use proptest::prelude::*;
use rust_decimal::Decimal;
use rust_decimal_macros::dec;
use super::*;
use crate::{
adapters::MockAdapter,
ports::{MarketDataSource, MarketEventStream, OverflowPolicy, PortError, TradingGateway},
proto::{market, trading},
};
#[test]
fn config_parses_from_params_table() {
let table: toml::Table = toml::from_str(
r#"
symbol = "SOLUSDT"
tenkan_period = 9
kijun_period = 26
senkou_b_period = 52
qty = "0.01"
"#,
)
.expect("valid toml");
let cfg = IchimokuConfig::from_params(&table).expect("parse");
assert_eq!(cfg.tenkan_period, 9);
assert_eq!(cfg.qty.to_string(), "0.01");
}
fn config() -> IchimokuConfig {
IchimokuConfig {
common: CommonParams {
exchange_id: "mock".to_string(),
label: String::new(),
symbol: "BTC/USDT".to_string(),
timeframe: "4h".to_string(),
poll_secs: 60,
},
tenkan_period: 3,
kijun_period: 5,
senkou_b_period: 10,
qty: dec!(0.5),
}
}
fn candle(high: Decimal, low: Decimal, close: Decimal) -> market::Candle {
market::Candle {
high: buffa::MessageField::some(longtrader_contract::ext::decimal_to_common(high)),
low: buffa::MessageField::some(longtrader_contract::ext::decimal_to_common(low)),
close: buffa::MessageField::some(longtrader_contract::ext::decimal_to_common(close)),
..Default::default()
}
}
struct ScriptedBars {
candles: StdArc<StdMutex<Vec<market::Candle>>>,
}
impl ScriptedBars {
fn of(candles: Vec<market::Candle>) -> Self {
Self { candles: StdArc::new(StdMutex::new(candles)) }
}
}
#[async_trait]
impl MarketDataSource for ScriptedBars {
async fn fetch_ticker(
&self,
_req: market::FetchTickerRequest,
) -> Result<market::Ticker, PortError> {
Err(PortError::Transport("no ticker".into()))
}
async fn fetch_order_book(
&self,
_req: market::FetchOrderBookRequest,
) -> Result<market::OrderBook, PortError> {
Err(PortError::Transport("no book".into()))
}
async fn get_candles(
&self,
_req: market::GetCandlesRequest,
) -> Result<market::GetCandlesResponse, PortError> {
let candles = self.candles.lock().expect("candles mutex").clone();
Ok(market::GetCandlesResponse { candles, ..Default::default() })
}
async fn list_symbols(
&self,
_req: market::ListSymbolsRequest,
) -> Result<market::ListSymbolsResponse, PortError> {
Err(PortError::Unsupported("no symbols".into()))
}
async fn search_symbols(
&self,
_req: market::SearchSymbolsRequest,
) -> Result<market::SearchSymbolsResponse, PortError> {
Err(PortError::Unsupported("no symbols".into()))
}
async fn list_tickers(
&self,
_req: market::ListTickersRequest,
) -> Result<market::ListTickersResponse, PortError> {
Err(PortError::Unsupported("no tickers".into()))
}
async fn subscribe_market_data(
&self,
_req: market::StreamMarketDataRequest,
_policy: OverflowPolicy,
) -> Result<MarketEventStream, PortError> {
Err(PortError::Unsupported("no stream".into()))
}
}
async fn run_strategy(candles: Vec<market::Candle>) -> (Arc<MockAdapter>, Ichimoku) {
let adapter = Arc::new(MockAdapter::new(dec!(100)));
let gateway: Arc<dyn TradingGateway> = adapter.clone();
let feed = Arc::new(ScriptedBars::of(candles));
let market: Arc<dyn MarketDataSource> = feed.clone();
(adapter, Ichimoku::new(config(), gateway, market))
}
async fn sides(adapter: &MockAdapter) -> Vec<buffa::EnumValue<trading::OrderSide>> {
adapter
.fetch_open_orders(trading::FetchOpenOrdersRequest::default())
.await
.expect("test setup")
.iter()
.map(|o| o.side)
.collect()
}
#[tokio::test]
async fn warmup_incomplete_places_nothing() {
let (adapter, strategy) = run_strategy(vec![
candle(dec!(100), dec!(90), dec!(95)),
candle(dec!(110), dec!(100), dec!(105)),
])
.await;
strategy.tick().await.expect("tick");
assert!(sides(&adapter).await.is_empty(), "must wait for full warmup");
}
#[tokio::test]
async fn bullish_setup_after_sufficient_history() {
let (adapter, strategy) = run_strategy(vec![
candle(dec!(100), dec!(90), dec!(95)),
candle(dec!(101), dec!(91), dec!(96)),
candle(dec!(102), dec!(92), dec!(97)),
candle(dec!(103), dec!(93), dec!(98)),
candle(dec!(105), dec!(94), dec!(100)),
candle(dec!(106), dec!(95), dec!(101)),
candle(dec!(107), dec!(96), dec!(102)),
candle(dec!(108), dec!(97), dec!(103)),
candle(dec!(109), dec!(98), dec!(104)),
candle(dec!(110), dec!(99), dec!(105)),
candle(dec!(150), dec!(140), dec!(148)), ])
.await;
strategy.tick().await.expect("tick");
let s = sides(&adapter).await;
assert!(s.len() <= 1, "at most one entry per tick");
}
proptest! {
#![proptest_config(ProptestConfig::with_cases(64))]
#[test]
fn a_poll_places_at_most_one_order(
closes in prop::collection::vec(1i64..10_000, 0..80),
) {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("a current-thread runtime");
let candles: Vec<market::Candle> = closes
.into_iter()
.map(|c| {
let c = Decimal::from(c);
candle(c + Decimal::ONE, c - Decimal::ONE, c)
})
.collect();
let (adapter, strategy) = runtime.block_on(run_strategy(candles));
runtime.block_on(strategy.tick()).expect("tick");
prop_assert!(runtime.block_on(sides(&adapter)).len() <= 1);
}
}
}