quantoxide 0.5.5

Rust framework for developing, backtesting, and deploying Bitcoin futures trading strategies.
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

use std::{result, sync::Arc};

use thiserror::Error;
use tokio::{
    sync::broadcast::error::{RecvError, SendError},
    task::JoinError,
};

use crate::{
    db::error::DbError, signal::error::SignalEvaluatorError,
    sync::process::error::SyncProcessFatalError,
};

#[derive(Error, Debug)]
#[non_exhaustive]
pub enum SignalProcessRecoverableError {
    #[error(transparent)]
    Evaluator(SignalEvaluatorError),

    #[error("[Db] {0}")]
    Db(#[from] DbError),

    #[error("`SyncRecvLagged` error, skipped: {skipped}")]
    SyncRecvLagged { skipped: u64 },
}

#[derive(Error, Debug)]
#[non_exhaustive]
pub enum SignalProcessFatalError {
    #[error(transparent)]
    Evaluator(SignalEvaluatorError),

    #[error("`Sync` process (dependency) was shutdown")]
    SyncProcessShutdown,

    #[error("Received unexpected `SyncStatus::Backfilled` from live sync process")]
    UnexpectedSyncBackfilled,

    #[error("`Sync` process (dependency) was terminated with error: {0}")]
    SyncProcessTerminated(Arc<SyncProcessFatalError>),

    #[error("`SyncRecvClosed` error")]
    SyncRecvClosed,

    #[error("TaskJoin error {0}")]
    LiveSignalProcessTaskJoin(JoinError),

    #[error("Shutdown `RecvError` error: {0}")]
    ShutdownSignalRecv(RecvError),

    #[error("Failed to send live signal process shutdown request error: {0}")]
    SendShutdownSignalFailed(SendError<()>),

    #[error("Live Signal shutdown timeout error")]
    ShutdownTimeout,
}

#[derive(Error, Debug)]
#[non_exhaustive]
pub enum SignalProcessError {
    #[error(transparent)]
    Recoverable(#[from] SignalProcessRecoverableError),

    #[error(transparent)]
    Fatal(#[from] SignalProcessFatalError),
}

pub(crate) type ProcessResult<T> = result::Result<T, SignalProcessError>;