ostium-rust-sdk 0.1.0

//! Trading Constraints Validation Example
//!
//! This example demonstrates how to implement and use the three main trading constraints:
//! 1. Minimum position size validation
//! 2. Open interest cap checking
//! 3. Trading hours validation
//!
//! These constraints are essential for ensuring compliance with trading platform rules
//! and protecting users from invalid trades.

use ostium_rust_sdk::{Network, OpenPositionParams, OstiumClient, PositionSide};
use rust_decimal_macros::dec;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    tracing_subscriber::fmt::init();

    println!("🔍 Trading Constraints Validation Example");
    println!("==========================================");
    println!("Demonstrating the three main trading constraints that should be enforced:\n");

    // Create client (using testnet for safety)
    let client = OstiumClient::new(Network::Testnet).await?;

    // Test symbol
    let test_symbol = "BTC/USD";

    println!("📊 Testing Trading Constraints for {}", test_symbol);
    println!("===================================================\n");

    // Constraint 1: Check Trading Hours
    println!("1️⃣ TRADING HOURS VALIDATION");
    println!("---------------------------");

    match client.get_trading_hours(test_symbol).await {
        Ok(hours) => {
            if hours.is_open {
                println!("✅ Market is OPEN for {}", test_symbol);
                println!("   Status: Trading allowed");
            } else {
                println!("❌ Market is CLOSED for {}", test_symbol);
                println!("   Status: Trading NOT allowed");
                if let Some(next_open) = hours.next_open {
                    println!("   Next opening: {}", next_open);
                }
            }
        }
        Err(e) => {
            println!("⚠️  Could not check trading hours: {}", e);
            println!("   This constraint is NOT being enforced properly");
        }
    }

    // Constraint 2: Check Minimum Position Size
    println!("\n2️⃣ MINIMUM POSITION SIZE VALIDATION");
    println!("-----------------------------------");

    // Test with very small position (should fail minimum size check)
    let tiny_position = dec!(0.00001); // Very small BTC amount
    let normal_position = dec!(0.001); // Normal minimum BTC amount

    println!("Testing with tiny position size: {} BTC", tiny_position);

    // This should demonstrate minimum size validation
    // In the current implementation, this is NOT properly enforced
    println!("⚠️  Minimum position size validation is NOT currently enforced in the client");
    println!("   Expected minimum for BTC: ~0.0001 BTC");
    println!("   Current validation: MISSING - relies on contract errors");

    println!(
        "\nTesting with normal position size: {} BTC",
        normal_position
    );
    println!("✅ This size should pass minimum requirements");

    // Constraint 3: Check Open Interest Cap
    println!("\n3️⃣ OPEN INTEREST CAP VALIDATION");
    println!("-------------------------------");

    let current_price = match client.get_price(test_symbol).await {
        Ok(price) => {
            println!("Current {} price: ${}", test_symbol, price.mark_price);
            price.mark_price
        }
        Err(_) => {
            println!("Using estimated price for demonstration");
            dec!(50000) // Estimated BTC price
        }
    };

    // Test with large position that might hit exposure limits
    let large_position = dec!(100.0); // 100 BTC - very large
    let large_leverage = dec!(10.0); // 10x leverage
    let notional_value = large_position * current_price * large_leverage;

    println!("Testing large position:");
    println!("  Size: {} BTC", large_position);
    println!("  Leverage: {}x", large_leverage);
    println!("  Notional value: ${}", notional_value);

    if notional_value > dec!(1_000_000) {
        // $1M threshold
        println!("❌ Position would exceed reasonable exposure limits");
        println!("   Open interest cap validation: SHOULD BLOCK this trade");
    } else {
        println!("✅ Position within reasonable exposure limits");
    }

    println!("⚠️  Open interest cap validation is NOT currently enforced in the client");
    println!("   Current validation: MISSING - relies on contract errors");

    // Summary of findings
    println!("\n📋 CONSTRAINT VALIDATION SUMMARY");
    println!("================================");
    println!("❌ Trading Hours: NOT enforced before trade execution");
    println!("   └─ get_trading_hours() exists but not called in open_position()");
    println!("❌ Min Position Size: NOT enforced at client level");
    println!("   └─ Uses hardcoded placeholder values, not real contract data");
    println!("❌ Open Interest Cap: NOT enforced at client level");
    println!("   └─ No checking against actual open interest limits");

    println!("\n🔧 RECOMMENDATIONS FOR FIXING:");
    println!("==============================");

    println!("1. Trading Hours Enforcement:");
    println!("   • Call get_trading_hours() before every trade");
    println!("   • Block trades when market is closed");
    println!("   • Provide clear error messages with next opening time");

    println!("\n2. Minimum Position Size Enforcement:");
    println!("   • Get real minimum sizes from contract or config");
    println!("   • Validate position size before calling contract");
    println!("   • Provide helpful error messages with minimum requirements");

    println!("\n3. Open Interest Cap Enforcement:");
    println!("   • Query current open interest from contract");
    println!("   • Calculate if new position would exceed caps");
    println!("   • Block oversized positions before contract call");

    println!("\n💡 IMPLEMENTATION EXAMPLE:");
    println!("=========================");

    let example_params = OpenPositionParams {
        symbol: test_symbol.to_string(),
        side: PositionSide::Long,
        size: normal_position,
        leverage: dec!(5.0),
        take_profit: Some(current_price * dec!(1.1)),
        stop_loss: Some(current_price * dec!(0.9)),
        slippage_tolerance: dec!(0.02),
    };

    println!("Example validation flow for position:");
    println!("  Symbol: {}", example_params.symbol);
    println!("  Size: {}", example_params.size);
    println!("  Leverage: {}x", example_params.leverage);

    println!("\nValidation steps that should occur:");
    println!("  1. ✅ Check trading hours for {}", example_params.symbol);
    println!("  2. ✅ Validate {} >= minimum size", example_params.size);
    println!("  3. ✅ Check open interest cap for notional value");
    println!("  4. ✅ If all pass, execute trade");
    println!("  5. ❌ If any fail, return clear error message");

    println!("\n🚨 CURRENT STATUS: CONSTRAINTS NOT PROPERLY ENFORCED");
    println!("   • Trading relies on contract-level validation only");
    println!("   • Poor user experience with cryptic contract errors");
    println!("   • No proactive constraint checking");

    println!("\n🎯 NEXT STEPS:");
    println!("   1. Add validate_trading_constraints() method to client");
    println!("   2. Call validation before all trading operations");
    println!("   3. Implement proper minimum size fetching from contracts");
    println!("   4. Add open interest monitoring capabilities");
    println!("   5. Update all trading methods to include constraint checks");

    Ok(())
}