Neural Trader Execution - IBKR Integration (100% Complete)

High-performance broker integrations for algorithmic trading with comprehensive IBKR support.

Features

• 11+ Broker Integrations - Stocks, crypto, forex, and options
• Smart Order Routing - Best execution across multiple venues
• Execution Algorithms - TWAP, VWAP, POV, ICEBERG
• Real-Time Order Management - WebSocket-based order status updates
• Rate Limiting - Per-broker rate limit enforcement
• Retry Logic - Automatic retry with exponential backoff
• Error Recovery - Handle broker outages gracefully
• Paper Trading - Test strategies without real capital
• Position Tracking - Real-time position and P&L updates

Supported Brokers

Stocks & ETFs

Cryptocurrency

Multi-Asset via CCXT

Quick Start

[dependencies]
nt-execution = "0.1"

Place Orders with Alpaca

use nt_execution::{
    brokers::AlpacaBroker,
    types::{Order, OrderType, Side, TimeInForce},
};
use rust_decimal::Decimal;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let broker = AlpacaBroker::new(
        std::env::var("ALPACA_API_KEY")?,
        std::env::var("ALPACA_SECRET_KEY")?,
        false, // paper trading = false
    ).await?;

    // Market order
    let order = Order {
        symbol: "AAPL".to_string(),
        side: Side::Buy,
        order_type: OrderType::Market,
        quantity: Decimal::from(10),
        time_in_force: TimeInForce::Day,
        ..Default::default()
    };

    let order_id = broker.place_order(order).await?;
    println!("Order placed: {}", order_id);

    // Monitor order status
    let status = broker.get_order_status(&order_id).await?;
    println!("Order status: {:?}", status);

    Ok(())
}

Smart Order Routing

use nt_execution::{
    SmartOrderRouter,
    types::{Order, RoutingStrategy},
};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let mut router = SmartOrderRouter::new();

    // Add brokers
    router.add_broker("alpaca", alpaca_broker);
    router.add_broker("ibkr", ibkr_broker);

    // Configure routing strategy
    router.set_strategy(RoutingStrategy::BestPrice);

    let order = Order {
        symbol: "AAPL".to_string(),
        side: Side::Buy,
        quantity: Decimal::from(100),
        order_type: OrderType::Limit,
        price: Some(Decimal::new(15000, 2)), // $150.00
        ..Default::default()
    };

    // Router automatically selects best broker
    let result = router.route_order(order).await?;
    println!("Order routed to: {}", result.broker);
    println!("Expected fill price: ${}", result.estimated_price);

    Ok(())
}

Execution Algorithms

use nt_execution::{
    algorithms::{TWAP, VWAP, Iceberg},
    types::AlgoOrder,
};
use chrono::{Utc, Duration};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let broker = AlpacaBroker::new(api_key, secret_key, false).await?;

    // TWAP (Time-Weighted Average Price)
    let twap = TWAP::new(
        "AAPL".to_string(),
        Side::Buy,
        Decimal::from(1000), // Total quantity
        Duration::hours(1),   // Execution window
        Duration::minutes(5), // Slice interval
    );

    let algo_order = AlgoOrder::TWAP(twap);
    let execution = broker.execute_algo(algo_order).await?;

    println!("TWAP execution completed");
    println!("Avg price: ${}", execution.avg_fill_price);
    println!("Total slippage: {:.2} bps", execution.slippage_bps);

    // VWAP (Volume-Weighted Average Price)
    let vwap = VWAP::new(
        "TSLA".to_string(),
        Side::Sell,
        Decimal::from(500),
        Duration::hours(2),
        0.10, // 10% of volume participation
    );

    broker.execute_algo(AlgoOrder::VWAP(vwap)).await?;

    // Iceberg Order
    let iceberg = Iceberg::new(
        "MSFT".to_string(),
        Side::Buy,
        Decimal::from(5000),  // Total quantity
        Decimal::from(100),   // Display quantity
        Some(Decimal::new(30000, 2)), // Limit price
    );

    broker.execute_algo(AlgoOrder::Iceberg(iceberg)).await?;

    Ok(())
}

Crypto Trading with Binance

use nt_execution::brokers::BinanceBroker;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let broker = BinanceBroker::new(
        std::env::var("BINANCE_API_KEY")?,
        std::env::var("BINANCE_SECRET_KEY")?,
    ).await?;

    // Spot order
    let order = Order {
        symbol: "BTCUSDT".to_string(),
        side: Side::Buy,
        order_type: OrderType::Limit,
        quantity: Decimal::new(1, 1), // 0.1 BTC
        price: Some(Decimal::from(45000)),
        time_in_force: TimeInForce::GTC,
        ..Default::default()
    };

    let order_id = broker.place_order(order).await?;

    // Subscribe to order updates
    let mut updates = broker.subscribe_orders().await?;

    while let Some(update) = updates.recv().await {
        println!("Order update: {:?}", update);
        if update.is_filled() {
            break;
        }
    }

    Ok(())
}

Position Management

use nt_execution::PositionManager;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let manager = PositionManager::new(broker);

    // Get current positions
    let positions = manager.get_positions().await?;
    for position in positions {
        println!(
            "{}: {} shares @ ${} (P&L: ${})",
            position.symbol,
            position.quantity,
            position.avg_entry_price,
            position.unrealized_pnl
        );
    }

    // Close a position
    manager.close_position("AAPL").await?;

    // Close all positions
    manager.close_all_positions().await?;

    Ok(())
}

Paper Trading

use nt_execution::brokers::PaperBroker;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let broker = PaperBroker::new(
        Decimal::from(100_000), // Initial capital
        market_data_provider,
    );

    // Place orders (simulated)
    let order = Order {
        symbol: "AAPL".to_string(),
        side: Side::Buy,
        quantity: Decimal::from(10),
        order_type: OrderType::Market,
        ..Default::default()
    };

    let order_id = broker.place_order(order).await?;

    // Paper broker simulates fill based on market data
    let fills = broker.get_fills(&order_id).await?;

    println!("Paper trade executed");
    println!("Fill price: ${}", fills[0].price);
    println!("Account balance: ${}", broker.get_balance().await?);

    Ok(())
}

Architecture

nt-execution/
├── brokers/
│   ├── alpaca.rs           # Alpaca implementation
│   ├── ibkr.rs             # Interactive Brokers
│   ├── binance.rs          # Binance
│   ├── coinbase.rs         # Coinbase
│   ├── ccxt.rs             # CCXT wrapper
│   └── paper.rs            # Paper trading
├── algorithms/
│   ├── twap.rs             # Time-weighted average price
│   ├── vwap.rs             # Volume-weighted average price
│   ├── pov.rs              # Percentage of volume
│   └── iceberg.rs          # Iceberg orders
├── router.rs               # Smart order routing
├── position_manager.rs     # Position tracking
├── order_manager.rs        # Order lifecycle management
├── types.rs                # Order types
└── lib.rs

Configuration

Create an execution.toml file:

[alpaca]
api_key = "${ALPACA_API_KEY}"
secret_key = "${ALPACA_SECRET_KEY}"
base_url = "https://api.alpaca.markets"
paper_trading = false

[binance]
api_key = "${BINANCE_API_KEY}"
secret_key = "${BINANCE_SECRET_KEY}"
testnet = false

[router]
strategy = "best_price"  # best_price, lowest_cost, fastest
max_slippage_bps = 50
max_latency_ms = 500

[rate_limits]
alpaca_orders_per_minute = 200
binance_orders_per_second = 10

Error Handling

use nt_execution::ExecutionError;

match broker.place_order(order).await {
    Ok(order_id) => println!("Order placed: {}", order_id),
    Err(ExecutionError::RateLimitExceeded { retry_after }) => {
        eprintln!("Rate limit hit, retry after: {:?}", retry_after);
        tokio::time::sleep(retry_after).await;
        // Retry logic
    }
    Err(ExecutionError::InsufficientFunds { required, available }) => {
        eprintln!("Insufficient funds: need ${}, have ${}", required, available);
    }
    Err(ExecutionError::OrderRejected { reason }) => {
        eprintln!("Order rejected: {}", reason);
    }
    Err(e) => eprintln!("Execution error: {}", e),
}

Dependencies

Testing

# Unit tests
cargo test -p nt-execution

# Integration tests (requires API keys)
export ALPACA_API_KEY=xxx
export ALPACA_SECRET_KEY=yyy
cargo test -p nt-execution --features integration

# Test specific broker
cargo test -p nt-execution alpaca

# Paper trading tests
cargo test -p nt-execution paper

Performance

Contributing

See CONTRIBUTING.md.

License

Licensed under MIT OR Apache-2.0.