API Reference

// JavaScript Example
const { BinaryOptionsAPI } = require('binary-options-tools');

const api = new BinaryOptionsAPI();

// Connect to demo account
try {
    const result = await api.connect({
        username: 'your_username',
        password: 'your_password',
        demo: true,
        timeout: 30000
    });
    
    if (result.success) {
        console.log(`Connected! Session ID: ${result.data.sessionId}`);
        console.log(`Account type: ${result.data.accountType}`);
    } else {
        console.log(`Connection failed: ${result.message}`);
    }
} catch (error) {
    console.error(`Error: ${error.message}`);
}

// Rust Example
use binary_options_tools::{BinaryOptionsAPI, ConnectionConfig};

#[tokio::main]
async fn main() -> Result<(), Box> {
    let api = BinaryOptionsAPI::new();
    
    // Connect to demo account
    let config = ConnectionConfig {
        username: "your_username".to_string(),
        password: "your_password".to_string(),
        demo: true,
        timeout: 30,
    };
    
    match api.connect(config).await {
        Ok(result) => {
            if result.success {
                println!("Connected! Session ID: {}", result.data.session_id);
                println!("Account type: {}", result.data.account_type);
            } else {
                println!("Connection failed: {}", result.message);
            }
        }
        Err(e) => println!("Error: {}", e),
    }
    
    Ok(())
}

// JavaScript Example
// Place a $10 CALL trade on EUR/USD for 1 minute
try {
    const result = await api.placeTrade({
        asset: 'EURUSD',
        amount: 10.0,
        direction: 'call',
        expiryTime: 60,
        tradeType: 'binary'
    });
    
    if (result.success) {
        const trade = result.data;
        console.log('Trade placed successfully!');
        console.log(`Trade ID: ${trade.tradeId}`);
        console.log(`Entry price: ${trade.entryPrice}`);
        console.log(`Expected payout: $${trade.expectedPayout}`);
        console.log(`Payout percentage: ${trade.payoutPercentage}%`);
    } else {
        console.log(`Trade failed: ${result.message}`);
    }
} catch (error) {
    console.error(`Error placing trade: ${error.message}`);
}

// Rust Example
use binary_options_tools::TradeRequest;

// Place a $10 CALL trade on EUR/USD for 1 minute
let trade_request = TradeRequest {
    asset: "EURUSD".to_string(),
    amount: 10.0,
    direction: "call".to_string(),
    expiry_time: 60,
    trade_type: Some("binary".to_string()),
};

match api.place_trade(trade_request).await {
    Ok(result) => {
        if result.success {
            let trade = result.data;
            println!("Trade placed successfully!");
            println!("Trade ID: {}", trade.trade_id);
            println!("Entry price: {}", trade.entry_price);
            println!("Expected payout: ${:.2}", trade.expected_payout);
            println!("Payout percentage: {}%", trade.payout_percentage);
        } else {
            println!("Trade failed: {}", result.message);
        }
    }
    Err(e) => println!("Error placing trade: {}", e),
}

// JavaScript Example
try {
    const result = await api.getBalance();
    
    if (result.success) {
        const balance = result.data;
        console.log(`Real balance: ${balance.realBalance} ${balance.currency}`);
        console.log(`Demo balance: ${balance.demoBalance} ${balance.currency}`);
        console.log(`Account type: ${balance.accountType}`);
    } else {
        console.log(`Failed to get balance: ${result.message}`);
    }
} catch (error) {
    console.error(`Error: ${error.message}`);
}

// Rust Example
match api.get_balance().await {
    Ok(result) => {
        if result.success {
            let balance = result.data;
            println!("Real balance: {:.2} {}", balance.real_balance, balance.currency);
            println!("Demo balance: {:.2} {}", balance.demo_balance, balance.currency);
            println!("Account type: {}", balance.account_type);
        } else {
            println!("Failed to get balance: {}", result.message);
        }
    }
    Err(e) => println!("Error: {}", e),
}

// JavaScript WebSocket Example
// Start price stream
const stream = api.startPriceStream({
    assets: ['EURUSD', 'GBPUSD', 'BTCUSD'],
    updateFrequency: 1000
});

// Listen for price updates
stream.on('price_update', (data) => {
    console.log(`${data.asset}: ${data.bid} / ${data.ask}`);
});

stream.on('candle_update', (data) => {
    console.log(`${data.asset} candle: O:${data.open} H:${data.high} L:${data.low} C:${data.close}`);
});

stream.on('error', (error) => {
    console.error('Stream error:', error);
});

// Start streaming
await stream.connect();

// Rust WebSocket Example
use futures::StreamExt;

// Start price stream
let mut stream = api.start_price_stream(vec![
    "EURUSD".to_string(),
    "GBPUSD".to_string(),
    "BTCUSD".to_string()
], 1000).await?;

// Listen for price updates
while let Some(price_update) = stream.next().await {
    match price_update {
        Ok(data) => {
            println!("{}: {} / {}", data.asset, data.bid, data.ask);
        }
        Err(e) => {
            eprintln!("Stream error: {}", e);
            break;
        }
    }
}