stock-trek 0.4.7

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

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

const BTC: &str = "BTC";
const USDT: &str = "USDT";

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

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

#[register_strategy(default)]
impl Strategy for CostAveraging {
    fn market_calculations(&self, context: StrategyContext) -> StockTrekResult<ScratchPad> {
        let mut scratch_pad = ScratchPad::new();
        if let Some(binance) = context.exchanges.get(&ExchangeId::Binance) {
            let btc_usdt = context.symbol(BTC, USDT);
            let market_opt = binance.market_for(&btc_usdt)?;
            if let Some(market) = market_opt {
                scratch_pad.write(&self.key_market_exists, true);
                let satoshi_price = market.ticks.ticks[0].last.price / 1_000_000.0;
                scratch_pad.write(&self.key_satoshi_price, satoshi_price);
            }
        }
        Ok(scratch_pad)
    }
    fn action_resolver(&self, context: ResolverContext) -> StockTrekResult<Resolver> {
        let exchange = ExchangeId::Binance;
        let satoshi_price = context.scratch_pad.number(&self.key_satoshi_price);
        let usdt = context.portfolio.asset_in_exchange(
            context.literals.exchange(exchange),
            context.literals.asset(USDT),
        );
        let can_buy = context
            .predicates
            .compare(usdt, Ordering::Greater, satoshi_price);
        let order_request = OrderRequest {
            account_type: AccountType::Spot,
            client_order_id: None,
            order_type: OrderType::Market,
            quantity: 1.0 / 1_000_000.0,
            reduce_only: false,
            side: OrderSide::Buy,
            symbol: Symbol::new(BTC, USDT),
            time_in_force: TimeInForce::Fok,
        };
        let buy_one_satoshi_action = context.actions.order_request(exchange, order_request);
        let buy_one_satoshi = context.resolvers.action(buy_one_satoshi_action);
        let no_op = context.resolvers.no_op();
        let market_exists = context.predicates.scratch_pad(&self.key_market_exists);
        let buy_if_possible = context.resolvers.if_else(can_buy, buy_one_satoshi, no_op);
        let do_nothing = context.resolvers.no_op();
        let resolver = context
            .resolvers
            .if_else(market_exists, buy_if_possible, do_nothing);
        Ok(resolver)
    }
}