hyper-agent-core 0.1.0

Core domain logic for hyper-agent: pipeline, executor, signals, positions
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

use std::sync::Arc;

use crate::account_state_ext::account_state_from_paper;
use crate::config::AppConfig;
use crate::error::{HyperAgentError, Result};
use crate::executor::{DryRunExecutor, OrderResult, OrderSubmitter, PaperExecutor};
use crate::pipeline::{OrderPipeline, PipelineContext, TradingMode};
use crate::pipeline_stages::*;
use crate::position_manager::PositionManager;
use crate::signal::{Side, SignalAction, TradeSignal};

pub struct PlaceOrderParams {
    pub market: String,
    pub side: Side,
    pub size: f64,
    pub price: Option<f64>,
}

pub async fn place_order(
    params: PlaceOrderParams,
    mode: TradingMode,
    pm: Arc<PositionManager>,
    config: Arc<AppConfig>,
    live_executor: Option<Arc<dyn OrderSubmitter>>,
) -> Result<OrderResult> {
    let signal = TradeSignal::manual(
        params.market.clone(),
        SignalAction::Open {
            side: params.side,
            size: params.size,
            price: params.price,
        },
        "order placement".into(),
    );

    let paper = Arc::new(PaperExecutor::new(Arc::clone(&pm)));
    let dry_run = Arc::new(DryRunExecutor);
    let pipeline = OrderPipeline::new(vec![
        Box::new(RiskGuardStage::new()),
        Box::new(OrderRouterStage::new(paper, live_executor, dry_run)),
        Box::new(NotifierStage::noop()),
        Box::new(LoggerStage),
    ]);

    let account_state = account_state_from_paper(&pm).await;
    let mut ctx = PipelineContext {
        mode,
        account_state,
        position_manager: pm,
        config,
        execution_results: vec![],
    };

    pipeline.execute(signal, &mut ctx).await?;

    ctx.execution_results
        .pop()
        .ok_or_else(|| HyperAgentError::ExecutionFailed("No execution result".into()))
}