stock-trek 0.7.2

Stock Trek time-series analysis
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use crate::prelude::*;
use std::cmp::Ordering;

pub struct CostAveraging {
    key_exchange: ScratchKey<ExchangeId>,
    key_market_exists: ScratchKey<bool>,
    key_satoshi_price: ScratchKey<f64>,
    key_satoshi_quantity: ScratchKey<f64>,
}

impl Default for CostAveraging {
    fn default() -> Self {
        Self {
            key_exchange: ScratchKey::new_required("EXCHANGE"),
            key_market_exists: ScratchKey::new_optional("MARKET_EXISTS", false),
            key_satoshi_price: ScratchKey::new_required("SATOSHI_PRICE"),
            key_satoshi_quantity: ScratchKey::new_required("SATOSHI_QUANTITY"),
        }
    }
}

#[register_strategy(default)]
impl Strategy for CostAveraging {
    fn preferences(&self) -> Preferences {
        Preferences {
            rounding: Rounding {
                price: RoundingStrategy::ToZero,
                quantity: RoundingStrategy::ToZero,
                callback_rate: RoundingStrategy::ToZero,
            },
            multi_leg: MultiLeg {
                if_different_price_unsupported: OnDifferent::UseDataFromPrimary,
                if_different_symbol_unsupported: OnDifferent::UseDataFromPrimary,
            },
        }
    }
    fn calculate(&self, c: &StrategyContext) -> ScratchPad {
        let mut scratch_pad = ScratchPad::new();
        let one_millionth = 1.0 / 1_000_000.0;
        scratch_pad.write(&self.key_satoshi_quantity, one_millionth);
        let iter = c.exchange_markets_for(AssetId::bitcoin_native(), AssetId::ethereum_usdt());
        let min_by_last_ask = iter.min_by(|(_a_exch, a_market), (_b_exch, b_market)| {
            let a_last_ask = a_market.ticks.ticks[0].ask.price;
            let b_last_ask = b_market.ticks.ticks[0].ask.price;
            a_last_ask.partial_cmp(&b_last_ask).unwrap()
        });
        if let Some((cheapest_exchange_name, market)) = min_by_last_ask {
            scratch_pad.write(&self.key_exchange, cheapest_exchange_name);
            scratch_pad.write(&self.key_market_exists, true);
            let satoshi_price = market.ticks.ticks[0].ask.price / 1_000_000.0;
            scratch_pad.write(&self.key_satoshi_price, satoshi_price);
        }
        scratch_pad
    }
    fn resolver(&self, c: &ResolverContext) -> Resolver {
        let exchange = c.scratch_pad.exchange_id(&self.key_exchange);
        let btc = c.literals.asset_id(AssetId::bitcoin_native());
        let usdt = c.literals.asset_id(AssetId::ethereum_usdt());
        let satoshi_price = c.scratch_pad.number(&self.key_satoshi_price);
        let quantity = c.scratch_pad.number(&self.key_satoshi_quantity);
        c.resolvers.if_else(
            c.predicates.scratch_pad(&self.key_market_exists),
            c.resolvers.if_else(
                c.predicates.compare(
                    c.portfolio
                        .asset_in_exchange(exchange.clone(), usdt.clone()),
                    Ordering::Greater,
                    satoshi_price,
                ),
                c.resolvers.enqueue_order(
                    exchange.clone(),
                    c.orders.single(
                        btc,
                        usdt.clone(),
                        OrderIntent::Open,
                        OrderSide::Buy,
                        OrderActivation::Immediate,
                        OrderPricing::Market,
                        OrderQuantity::OfQuote(quantity),
                        vec![OrderConstraint::FillPolicy {
                            allow_partial: true,
                        }],
                    ),
                ),
                c.resolvers.no_op(),
            ),
            c.resolvers.no_op(),
        )
    }
}