Fixed parsing in get_candle with context for Pocket Option API changes

BinaryOptionsToolsJs/index.d.ts

@@ -280,6 +280,26 @@ export declare class PocketOption {
    * ```
    */
   getCandles(asset: string, period: number, offset: number): Promise<any>
+  /**
+   * Retrieves historical candle data for an asset with time
+   *
+   * # Arguments
+   * * `asset` - The trading asset/symbol (e.g., "EUR/USD")
+   * * `time` - The UNIX timestamp for the start of the candle data
+   * * `period` - The candle period in seconds
+   * * `offset` - Time offset for historical data
+   *
+   * # Returns
+   * A JSON string containing the candle data
+   *
+   * # Examples
+   * ```javascript
+   * const candles = await client.getCandlesAdvanced("EUR/USD", 1751925016, 60, 6000);
+   * const data = JSON.parse(candles);
+   * console.log(`Retrieved ${data.length} candles`);
+   * ```
+   */
+  getCandlesAdvanced(asset: string, time: number, period: number, offset: number): Promise<any>
   /**
    * Retrieves the current account balance.
    *
@@ -558,6 +578,8 @@ export declare class PocketOption {
    * ```
    */
   createRawIterator(message: string, validator: Validator, timeout?: number | undefined | null): Promise<RawStreamIterator>
+  /** Returns the current server time as a UNIX timestamp */
+  getServerTime(): Promise<number>
 }
 /**
  * A validator for WebSocket messages that provides various matching strategies.

BinaryOptionsToolsJs/src/pocketoption.rs

@@ -278,6 +278,33 @@ impl PocketOption {
         serde_json::to_value(&res).map_err(|e| Error::from_reason(e.to_string()))
     }
 
+    /// Retrieves historical candle data for an asset with time
+    ///
+    /// # Arguments
+    /// * `asset` - The trading asset/symbol (e.g., "EUR/USD")
+    /// * `time` - The UNIX timestamp for the start of the candle data
+    /// * `period` - The candle period in seconds
+    /// * `offset` - Time offset for historical data
+    ///
+    /// # Returns
+    /// A JSON string containing the candle data
+    ///
+    /// # Examples
+    /// ```javascript
+    /// const candles = await client.getCandlesAdvanced("EUR/USD", 1751925016, 60, 6000);
+    /// const data = JSON.parse(candles);
+    /// console.log(`Retrieved ${data.length} candles`);
+    /// ```
+    #[napi]
+    pub async fn get_candles_advanced(&self, asset: String, time: i64, period: i64, offset: i64) -> Result<Value> {
+        let res = self
+            .client
+            .get_candles_advanced(asset, time, period, offset)
+            .await
+            .map_err(|e| Error::from_reason(e.to_string()))?;
+        serde_json::to_value(&res).map_err(|e| Error::from_reason(e.to_string()))
+    }
+
     /// Retrieves the current account balance.
     ///
     /// # Returns

Cargo.toml

@@ -1,6 +1,11 @@
 [workspace]
 resolver = "2"
 
+exclude = [
+    "BinaryOptionsToolsJs",
+    "BinaryOptionsToolsV2"
+]
+
 members = [
     "crates/binary_options_tools",
     "crates/core", "crates/core-pre",

crates/binary_options_tools/src/pocketoption/parser/message.rs

@@ -42,6 +42,8 @@ pub enum WebSocketMessage {
     GetCandles(LoadHistoryPeriod),
 
     LoadHistoryPeriod(LoadHistoryPeriodResult),
+    LoadHistoryPeriodFast(LoadHistoryPeriodResult),
+
     UpdateStream(UpdateStream),
     UpdateHistoryNew(UpdateHistoryNewFast),
 
@@ -101,6 +103,9 @@ impl WebSocketMessage {
                 if let Ok(stream) = from_str::<UpdateStream>(&data) {
                     return Self::UpdateStream(stream);
                 }
+                if let Ok(stream) = from_str::<LoadHistoryPeriodResult>(&data) {
+                    return Self::LoadHistoryPeriod(stream);
+                }
             }
             MessageInfo::UpdateHistoryNew => {
                 if let Ok(history) = from_str::<UpdateHistoryNewFast>(&data) {
@@ -177,6 +182,11 @@ impl WebSocketMessage {
                     return Self::LoadHistoryPeriod(history);
                 }
             }
+            MessageInfo::LoadHistoryPeriodFast => {
+                if let Ok(history) = from_str::<LoadHistoryPeriodResult>(&data) {
+                    return Self::LoadHistoryPeriod(history);
+                }
+            }
             // MessageInfo::UpdateCharts => {
             //     return Err(PocketOptionError::GeneralParsingError(
             //         "This is expected, there is no parser for the 'updateCharts' message"
@@ -240,6 +250,7 @@ impl WebSocketMessage {
             Self::UpdateOpenedDeals(_) => MessageInfo::UpdateOpenedDeals,
             Self::SubscribeSymbol(_) => MessageInfo::SubscribeSymbol,
             Self::LoadHistoryPeriod(_) => MessageInfo::LoadHistoryPeriod,
+            Self::LoadHistoryPeriodFast(_) => MessageInfo::LoadHistoryPeriodFast,
             Self::GetCandles(_) => MessageInfo::GetCandles,
             Self::FailOpenOrder(_) => MessageInfo::FailopenOrder,
             Self::SuccessupdatePending(_) => MessageInfo::SuccessupdatePending,
@@ -334,6 +345,16 @@ impl fmt::Display for WebSocketMessage {
                     serde_json::to_string(&period).map_err(|_| fmt::Error)?
                 )
             }
+            // 451-["loadHistoryPeriodFast",{"_placeholder":true,"num":0}]
+            WebSocketMessage::LoadHistoryPeriodFast(period) => {
+                write!(
+                    f,
+                    "451-[{}, {}]",
+                    serde_json::to_string(&MessageInfo::LoadHistoryPeriod)
+                        .map_err(|_| fmt::Error)?,
+                    serde_json::to_string(&period).map_err(|_| fmt::Error)?
+                )
+            }
             WebSocketMessage::FailOpenOrder(order) => order.fmt(f),
             WebSocketMessage::SuccessupdatePending(pending) => pending.fmt(f),
             WebSocketMessage::Subfor(sub) => write!(f, "42[\"subfor\",{}]", sub),

crates/binary_options_tools/src/pocketoption/types/info.rs

@@ -25,6 +25,7 @@ pub enum MessageInfo {
     // UpdateCharts,
     SubscribeSymbol,
     LoadHistoryPeriod,
+    LoadHistoryPeriodFast,
     FailopenOrder,
     GetCandles,
     OpenPendingOrder,

crates/binary_options_tools/src/pocketoption/types/update.rs

@@ -36,9 +36,20 @@ pub struct LoadHistoryPeriodResult {
 pub enum Candle {
     Raw(RawCandle),
     Processed(ProcessedCandle),
+    ProcessedNew(ProcessedCandleNew),
     Update(UpdateCandle),
 }
 
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct ProcessedCandleNew {
+    symbol_id: i32,
+    time: i64, // use i64 for timestamp to avoid precision issues
+    open: f64,
+    close: f64,
+    high: f64,
+    low: f64,
+}
+
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct RawCandle {
     asset: String,
@@ -159,6 +170,13 @@ impl From<&Candle> for DataCandle {
                 candle.high,
                 candle.low,
             ),
+            Candle::ProcessedNew(candle) => Self::new(
+                DateTime::from_timestamp(candle.time, 0).expect("REASON"),
+                candle.open,
+                candle.close,
+                candle.high,
+                candle.low,
+            ),
             Candle::Update(candle) => Self::new_price(candle.time, candle.price),
         }
     }

crates/core/data/client_enhanced.rs

@@ -675,6 +675,14 @@ where
                             ))
                             .await?;
                     }
+                    "loadHistoryPeriodFast" => {
+                        event_manager
+                            .emit(Event::new(
+                                EventType::Custom("candles_received".to_string()),
+                                event_data.clone(),
+                            ))
+                            .await?;
+                    }
                     _ => {
                         event_manager
                             .emit(Event::new(