binary_options_tools 0.2.0

High-level library for binary options trading automation. Supports PocketOption and ExpertOption with real-time data streaming, WebSocket API access, and automated 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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use binary_options_tools_core_pre::traits::AppState;
use chrono::Local;
use rust_decimal::{dec, Decimal};
use tokio::sync::RwLock;

use crate::expertoptions::{modules::profile::Demo, types::Assets};

pub struct Config {
    pub user_agent: String,
}

pub struct Balance {
    pub real: Decimal,
    pub demo: Decimal,
}

pub struct State {
    /// Session ID for the account
    pub token: String,
    /// Balance of the account
    pub balance: RwLock<Option<Balance>>,
    /// Indicates if the account is a demo account
    pub demo: RwLock<Demo>,
    /// Configuration for the ExpertOptions client
    pub config: RwLock<Config>,
    /// Current timezone (UTC offset)
    pub timezone: RwLock<i32>,
    /// Get candles allowed timeframes
    pub get_candles_timeframes: RwLock<Vec<u32>>,
    /// Maps how often point data is returned by server
    pub points_timeframe: RwLock<Decimal>,
    /// Assets
    pub assets: RwLock<Option<Assets>>,
}

impl Config {
    pub fn new(user_agent: String) -> Self {
        Config { user_agent }
    }
}

impl Default for Config {
    fn default() -> Self {
        Config {
            user_agent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 OPR/120.0.0.0".to_string(),
        }
    }
}

#[async_trait::async_trait]
impl AppState for State {
    async fn clear_temporal_data(&self) {
        // Clear any temporary data associated with the state
    }
}

impl State {
    pub fn new(token: String, demo: bool) -> Self {
        let timezone = Local::now().offset().local_minus_utc().div_euclid(60);
        dbg!(timezone);
        State {
            token,
            balance: RwLock::new(None),
            demo: RwLock::new(Demo::new(demo)),
            config: RwLock::new(Config::default()),
            timezone: RwLock::new(timezone), // Default to UTC
            get_candles_timeframes: RwLock::new(Vec::new()),
            assets: RwLock::new(None),
            points_timeframe: RwLock::new(dec!(0.5)), // Default to .5 seconds
        }
    }

    pub async fn set_demo(&self, demo: Demo) {
        *self.demo.write().await = demo;
    }

    pub async fn is_demo(&self) -> bool {
        self.demo.read().await.is_demo()
    }

    pub async fn user_agent(&self) -> String {
        self.config.read().await.user_agent.clone()
    }

    pub async fn set_assets(&self, assets: Assets) {
        *self.assets.write().await = Some(assets);
    }

    pub async fn set_balance(&self, balance: Balance) {
        *self.balance.write().await = Some(balance);
    }

    pub async fn set_timeframes(&self, candles: Vec<u32>, points: Decimal) {
        *self.get_candles_timeframes.write().await = candles;
        *self.points_timeframe.write().await = points;
    }

    pub async fn get_balance(&self) -> Decimal {
        let demo = self.is_demo().await;
        match &*self.balance.read().await {
            Some(balance) => {
                if demo {
                    balance.demo
                } else {
                    balance.real
                }
            }
            None => dec!(-1),
        }
    }

    pub async fn get_points_timeframe(&self) -> Decimal {
        *self.points_timeframe.read().await
    }

    pub async fn validate_candle_timeframe(&self, timeframe: u32) -> bool {
        self.get_candles_timeframes
            .read()
            .await
            .contains(&timeframe)
    }
}