Merge pull request #112 from sixtysixx/master

various fixes

Author: sixtysixx

.github/workflows/CI.yml

@@ -85,25 +85,38 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        target: [x64, x86]
+        include:
+          - target: x86_64-pc-windows-msvc
+            arch: x64
+          - target: i686-pc-windows-msvc
+            arch: x86
+    env:
+      RUSTC_WRAPPER: ""  # Disable sccache for Windows
+      SCCACHE_GHA_ENABLED: "false"
     steps:
       - uses: actions/checkout@v4
-      - name: Run sccache-cache
-        uses: mozilla/sccache-action@v0.0.6
+        with:
+          persist-credentials: false
+      # Disable sccache for windows due to potential cross-compilation issues
+      # - name: Run sccache-cache
+      #   uses: mozilla/sccache-action@v0.0.6
       - uses: actions/setup-python@v5
+        id: setup-python
         with:
           python-version: "3.13.12"
-          architecture: ${{ matrix.target }}
+          architecture: ${{ matrix.arch }}
       - name: Build wheels
         uses: PyO3/maturin-action@v1
+        env:
+          PYO3_PYTHON: ${{ steps.setup-python.outputs.python-path }}
         with:
           target: ${{ matrix.target }}
-          args: --release --strip --out dist -i python3.13
+          args: --release --strip --out dist -i "${{ steps.setup-python.outputs.python-path }}"
           working-directory: python
       - name: Upload wheels
         uses: actions/upload-artifact@v4
         with:
-          name: wheels-windows-${{ matrix.target }}
+          name: wheels-windows-${{ matrix.arch }}
           path: python/dist
 
   # --- 3. MACOS BUILD ---

README.md

@@ -121,19 +121,19 @@ Install directly from our GitHub releases. Supports **Python 3.9 - 3.12**.
 **Windows**
 
 ```bash
-pip install "https://github.com/ChipaDevTeam/BinaryOptionsTools-v2/releases/download/v0.2.9/binaryoptionstoolsv2-0.2.9-cp39-abi3-win_amd64.whl"
+pip install "https://github.com/ChipaDevTeam/BinaryOptionsTools-v2/releases/download/v0.2.11/binaryoptionstoolsv2-0.2.11-cp39-abi3-win_amd64.whl"
 ```
 
 **Linux**
 
 ```bash
-pip install "https://github.com/ChipaDevTeam/BinaryOptionsTools-v2/releases/download/v0.2.9/binaryoptionstoolsv2-0.2.9-cp39-abi3-manylinux_2_28_x86_64.whl"
+pip install "https://github.com/ChipaDevTeam/BinaryOptionsTools-v2/releases/download/v0.2.11/binaryoptionstoolsv2-0.2.11-cp39-abi3-manylinux_2_28_x86_64.whl"
 ```
 
 **macOS (Apple Silicon)**
 
 ```bash
-pip install "https://github.com/ChipaDevTeam/BinaryOptionsTools-v2/releases/download/v0.2.9/binaryoptionstoolsv2-0.2.9-cp39-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl"
+pip install "https://github.com/ChipaDevTeam/BinaryOptionsTools-v2/releases/download/v0.2.11/binaryoptionstoolsv2-0.2.11-cp39-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl"
 ```
 
 #### Option B: Build from Source

codemap.md

@@ -20,7 +20,7 @@ chrono = { workspace = true }
 # binary-options-tools-core = { path = "../core", version = "0.2.0" }
 # trading-macros = { path = "../macros" }
 futures-util = { workspace = true }
-reqwest = { version = "0.13.4", default-features = false, features = ["rustls-tls", "json"] }
+reqwest = { version = "0.13.4", default-features = false, features = ["rustls-no-provider", "json"] }
 serde = { workspace = true }
 serde_json = { workspace = true }
 tokio = { workspace = true }

crates/binary_options_tools/Cargo.toml

@@ -28,7 +28,7 @@ use binary_options_tools::pocketoption::{
     error::PocketResult,
     ssid::{Demo, Ssid},
     state::{State, StateBuilder},
-    types::PendingOrder,
+    types::{PendingOrder, OpenPendingOrder},
 };
 use binary_options_tools_core::reimports::Message;
 use binary_options_tools_core::traits::{ApiModule, RunnerCommand};
@@ -154,16 +154,16 @@ async fn example_basic_pending_order() -> PocketResult<()> {
     });
 
     let result = client_handle
-        .open_pending_order(
-            1,                                         // open_type: 1 = typical for binary options
-            Decimal::from_f64_retain(100.0).unwrap(),  // amount
-            "EURUSD_otc".to_string(),                  // asset (OTC EUR/USD)
-            "2026-04-07 22:50:00".to_string(),          // open_time: specific trigger time (for openType 0) or expiration (for openType 1)
-            Decimal::from_f64_retain(1.1950).unwrap(), // open_price: current market price
-            60,                                        // timeframe: 60 seconds
-            85,                                        // min_payout: 85% minimum payout
-            0,                                         // command: 0 (typically for buy/call)
-        )
+        .open_pending_order(OpenPendingOrder {
+            open_type: 1,                                         // open_type: 1 = typical for binary options
+            amount: Decimal::from_f64_retain(100.0).unwrap(),  // amount
+            asset: "EURUSD_otc".to_string(),                  // asset (OTC EUR/USD)
+            open_time: "2026-04-07 22:50:00".to_string(),          // open_time: specific trigger time (for openType 0) or expiration (for openType 1)
+            open_price: Decimal::from_f64_retain(1.1950).unwrap(), // open_price: current market price
+            timeframe: 60,                                        // timeframe: 60 seconds
+            min_payout: 85,                                        // min_payout: 85% minimum payout
+            command: 0,                                         // command: 0 (typically for buy/call)
+        })
         .await;
 
     // 7. Handle the result
@@ -262,16 +262,16 @@ async fn example_concurrent_pending_orders() -> PocketResult<()> {
 
             let order_fut = tokio::spawn(async move {
                 handle_clone2
-                    .open_pending_order(
-                        1,
-                        amount2,
-                        asset2,
-                        "2026-04-07 22:50:00".to_string(),
-                        Decimal::from_f64_retain(1.0).unwrap(),
-                        60,
-                        85,
-                        0,
-                    )
+                    .open_pending_order(OpenPendingOrder {
+                        open_type: 1,
+                        amount: amount2,
+                        asset: asset2,
+                        open_time: "2026-04-07 22:50:00".to_string(),
+                        open_price: Decimal::from_f64_retain(1.0).unwrap(),
+                        timeframe: 60,
+                        min_payout: 85,
+                        command: 0,
+                    })
                     .await
             });
 
@@ -456,16 +456,16 @@ async fn example_integration_with_pocketclient() -> PocketResult<()> {
 
     let order_result = timeout(
         Duration::from_secs(30),
-        pending_trades_handle.open_pending_order(
-            1,
-            Decimal::from_f64_retain(250.0).unwrap(),
-            "EURUSD_otc".to_string(),
-            "2026-04-07 22:50:00".to_string(),
-            Decimal::from_f64_retain(1.1850).unwrap(),
-            60,
-            90,
-            0,
-        ),
+        pending_trades_handle.open_pending_order(OpenPendingOrder {
+            open_type: 1,
+            amount: Decimal::from_f64_retain(250.0).unwrap(),
+            asset: "EURUSD_otc".to_string(),
+            open_time: "2026-04-07 22:50:00".to_string(),
+            open_price: Decimal::from_f64_retain(1.1850).unwrap(),
+            timeframe: 60,
+            min_payout: 90,
+            command: 0,
+        }),
     )
     .await;
 
@@ -537,8 +537,16 @@ async fn scenario1_mismatched_responses() -> PocketResult<()> {
     });
 
     println!("Waiting for order (should handle mismatches)...");
-    // This might still fail if the module's matching logic is strict, but it demonstrates the retry loop
-    let _ = client_handle.open_pending_order(1, dec!(100), "EURUSD_otc".into(), "2026-04-07 22:50:00".into(), dec!(1.1950), 60, 85, 0).await;
+    let _ = client_handle.open_pending_order(OpenPendingOrder {
+        open_type: 1,
+        amount: dec!(100),
+        asset: "EURUSD_otc".into(),
+        open_time: "2026-04-07 22:50:00".into(),
+        open_price: dec!(1.1950),
+        timeframe: 60,
+        min_payout: 85,
+        command: 0,
+    }).await;
 
     module_task.abort();
     Ok(())
@@ -567,7 +575,16 @@ async fn scenario3_timeout() -> PocketResult<()> {
     let module_task = tokio::spawn(async move { module.run().await.ok() });
 
     println!("Requesting order with no server response (expect timeout)...");
-    let result = timeout(Duration::from_secs(2), client_handle.open_pending_order(1, dec!(100), "EURUSD_otc".into(), "2026-04-07 22:50:00".into(), dec!(1.1950), 60, 85, 0)).await;
+    let result = timeout(Duration::from_secs(2), client_handle.open_pending_order(OpenPendingOrder {
+        open_type: 1,
+        amount: dec!(100),
+        asset: "EURUSD_otc".into(),
+        open_time: "2026-04-07 22:50:00".into(),
+        open_price: dec!(1.1950),
+        timeframe: 60,
+        min_payout: 85,
+        command: 0,
+    })).await;
 
     match result {
         Err(_) => println!("✓ Correctly timed out!"),

crates/binary_options_tools/examples/pending_trades_example.rs

@@ -112,8 +112,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
 
     println!("\n=== Test 4: Custom max_subscriptions ===");
-    let mut config = Config::default();
-    config.max_subscriptions = 8;
+    let config = Config {
+        max_subscriptions: 8,
+        ..Default::default()
+    };
     let client2 = PocketOption::new_with_config(&ssid, config).await?;
     tokio::time::sleep(Duration::from_secs(3)).await;
 

crates/binary_options_tools/examples/test_demo.rs

@@ -304,8 +304,8 @@ impl ApiModule<State> for ProfileModule {
             ) -> CoreResult<()> {
                 // On reconnect, re-send multipleAction and ensure context if demo
                 let token = state.token.clone();
-                let timezone = state.timezone.read().await;
-                let multi = multiple_action_action(token.clone(), *timezone)?.to_message()?;
+                let timezone = *state.timezone.read().await;
+                let multi = multiple_action_action(token.clone(), timezone)?.to_message()?;
                 ws_sender.send(multi).await?;
                 if state.is_demo().await {
                     let demo = Demo::new(true);
@@ -325,10 +325,12 @@ impl ApiModule<State> for ProfileModule {
 impl ProfileModule {
     async fn send_startup_messages(&self) -> CoreResult<()> {
         let token = self.state.token.clone();
-        let timezone = self.state.timezone.read().await;
+        let timezone = *self.state.timezone.read().await;
         // Ensure demo context if currently demo
-        if dbg!(self.state.is_demo().await) {
-            dbg!("Sent demo message");
+        let is_demo = self.state.is_demo().await;
+        debug!("Current demo state: {}", is_demo);
+        if is_demo {
+            debug!("Sending demo context startup message");
             let demo = Demo::new(true);
             let msg = demo
                 .action(token.clone())
@@ -337,7 +339,7 @@ impl ProfileModule {
             self.ws_sender.send(msg).await?;
         }
         // Send multipleAction with basic actions placeholder (can be extended)
-        let multi = multiple_action_action(token, *timezone)?.to_message()?;
+        let multi = multiple_action_action(token, timezone)?.to_message()?;
         self.ws_sender.send(multi).await?;
         Ok(())
     }

crates/binary_options_tools/src/expertoptions/modules/profile.rs

@@ -2,6 +2,7 @@ use binary_options_tools_core::traits::AppState;
 use chrono::Local;
 use rust_decimal::{dec, Decimal};
 use tokio::sync::RwLock;
+use tracing::info;
 
 use crate::expertoptions::{modules::profile::Demo, types::Assets};
 
@@ -57,7 +58,7 @@ impl AppState for State {
 impl State {
     pub fn new(token: String, demo: bool) -> Self {
         let timezone = Local::now().offset().local_minus_utc().div_euclid(60);
-        dbg!(timezone);
+        info!("Timezone offset: {}", timezone);
         State {
             token,
             balance: RwLock::new(None),

crates/binary_options_tools/src/expertoptions/state.rs

@@ -31,7 +31,6 @@ pub mod error;
 pub mod expertoptions;
 pub mod framework;
 pub mod pocketoption;
-pub mod reimports;
 pub mod traits;
 pub mod utils;
 pub mod validator;
@@ -49,7 +48,7 @@ mod tests {
     use tokio::time::sleep;
     use tracing::debug;
 
-    use binary_options_tools_macros::{deserialize, serialize, timeout};
+    use binary_options_tools_macros::timeout;
     #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
     struct Test {
         name: String,
@@ -60,8 +59,8 @@ mod tests {
         let test = Test {
             name: "Test".to_string(),
         };
-        let test_str = serialize!(&test).unwrap();
-        let test2 = deserialize!(Test, &test_str).unwrap();
+        let test_str = serde_json::to_string(&test).unwrap();
+        let test2 = serde_json::from_str::<Test>(&test_str).unwrap();
         assert_eq!(test, test2)
     }
 

crates/binary_options_tools/src/lib.rs

@@ -121,14 +121,7 @@ impl PendingTradesHandle {
     /// Creates a new pending order on the PocketOption platform.
     pub async fn open_pending_order(
         &self,
-        open_type: u32,
-        amount: Decimal,
-        asset: String,
-        open_time: String,
-        open_price: Decimal,
-        timeframe: u32,
-        min_payout: u32,
-        command: u32,
+        order: OpenPendingOrder,
     ) -> PocketResult<PendingOrder> {
         let _lock = self.call_lock.lock().await;
 
@@ -138,11 +131,22 @@ impl PendingTradesHandle {
         }
 
         let id = Uuid::new_v4();
+        let OpenPendingOrder {
+            open_type,
+            amount,
+            asset: order_asset,
+            open_time,
+            open_price,
+            timeframe,
+            min_payout,
+            command,
+        } = order;
+        let asset = order_asset.clone();
         self.sender
             .send(Command::OpenPendingOrder {
                 open_type,
                 amount,
-                asset: asset.clone(),
+                asset: order_asset,
                 open_time,
                 open_price,
                 timeframe,