first commit

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,23 @@
+# syntax=docker/dockerfile:1
+FROM rust:1.75 as builder
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y pkg-config libssl-dev
+
+COPY rust-api/Cargo.toml rust-api/Cargo.lock ./
+RUN cargo build --release
+
+FROM debian:bookworm-slim
+
+RUN apt-get update && apt-get install -y \
+    ca-certificates \
+    curl \
+    libssl3 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY --from=builder /app/target/release/rapid-live-client /usr/local/bin/
+
+EXPOSE 3000
+
+CMD ["rapid-live-client"]

README.md

@@ -1,12 +1,100 @@
 ---
 title: RapidLiveClient
-emoji: 📉
-colorFrom: indigo
-colorTo: gray
+emoji: 📈
+colorFrom: red
+colorTo: green
 sdk: docker
+app_port: 3000
 pinned: false
-license: cc-by-nc-4.0
-short_description: The live trading AI for RapidQuant microservice tool
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 📈 RapidLiveClient - Trading API
+
+API de trading en vivo con Rust + FastAPI. Conectado a Binance.
+
+## ⚠️ Aviso非常重要
+
+Este es un proyecto de trading algorítmico. 
+- Usar solo en **testnet** inicialmente
+- No invertir más de lo que puedas perder
+- Los resultados pasados no garantizan resultados futuros
+
+## 📡 Endpoints
+
+| Método | Endpoint | Descripción |
+|--------|----------|-------------|
+| GET | `/` | Estado del servicio |
+| GET | `/health` | Health check |
+| GET | `/api/balance` | Balance de cuenta |
+| GET | `/api/positions` | Posiciones abiertas |
+| GET | `/api/orders` | Historial de órdenes |
+| POST | `/api/orders` | Crear orden |
+| POST | `/api/positions/close` | Cerrar posición |
+| POST | `/api/analyze` | Análisis de mercado |
+
+## 📥 Uso
+
+### Obtener Balance
+```bash
+curl https://tu-usuario-RapidLiveClient.huggingface.space/api/balance
+```
+
+### Crear Orden
+```bash
+curl -X POST https://tu-usuario-RapidLiveClient.huggingface.space/api/orders \
+  -H "Content-Type: application/json" \
+  -d '{"symbol": "BTCUSDT", "side": "BUY", "quantity": 0.01}'
+```
+
+### Analizar Mercado
+```bash
+curl -X POST https://tu-usuario-RapidLiveClient.huggingface.space/api/analyze \
+  -H "Content-Type: application/json" \
+  -d '{"symbol": "BTCUSDT"}'
+```
+
+## 🔧 Configuración
+
+### Variables de Entorno (Repository secrets)
+- `BINANCE_API_KEY`: Tu API key de Binance
+- `BINANCE_API_SECRET`: Tu API secret de Binance
+
+## 🔍 Verificar Conexión (Terminal)
+
+```bash
+# Estado del servicio
+curl https://tu-usuario-RapidLiveClient.huggingface.space/
+
+# Health check
+curl https://tu-usuario-RapidLiveClient.huggingface.space/health
+
+# Ver balance
+curl https://tu-usuario-RapidLiveClient.huggingface.space/api/balance
+
+# Ver posiciones
+curl https://tu-usuario-RapidLiveClient.huggingface.space/api/positions
+```
+
+## 📊 Estrategia
+
+El agente usa:
+- **RSI** para sobrecompra/sobreventa
+- **Medias móviles** para tendencia
+- **Stop loss** configurable (5%)
+- **Take profit** automático (10%)
+
+## 🔗 Consumido por
+
+- **RapidQuant** - Frontend principal
+
+## 🚀 Despliegue
+
+1. Crea el Space en HuggingFace
+2. Configura tus API keys de Binance en secrets
+3. Despliega
+
+### Build local
+```bash
+docker build -t rapid-live-client .
+docker run -p 3000:3000 -e BINANCE_API_KEY=xxx -e BINANCE_API_SECRET=xxx rapid-live-client
+```

rust-api/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "rapid-live-client"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+axum = "0.7"
+tokio = { version = "1", features = ["full"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+reqwest = { version = "0.11", features = ["json"] }
+rust_decimal = { version = "1", features = ["serde"] }
+chrono = { version = "0.4", features = ["serde"] }
+tracing = "0.1"
+tracing-subscriber = "0.3"
+anyhow = "1"
+thiserror = "1"
+
+[dependencies.nautilus]
+version = "0.3"
+features = ["rustpython", "external-api"]
+
+[features]
+default = []
+binance = ["nautilus/binance"]

rust-api/src/binance.rs

@@ -0,0 +1,97 @@
+// Binance API module
+// Integration with Binance for live trading
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BinanceConfig {
+    pub api_key: String,
+    pub api_secret: String,
+    pub testnet: bool,
+}
+
+impl BinanceConfig {
+    pub fn base_url(&self) -> &str {
+        if self.testnet {
+            "https://testnet.binance.vision/api"
+        } else {
+            "https://api.binance.com/api"
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BinanceKline {
+    pub open_time: i64,
+    pub open: f64,
+    pub high: f64,
+    pub low: f64,
+    pub close: f64,
+    pub volume: f64,
+    pub close_time: i64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BinanceTicker {
+    pub symbol: String,
+    pub last_price: f64,
+    pub price_change_percent: f64,
+    pub volume: f64,
+}
+
+pub struct BinanceClient {
+    config: BinanceConfig,
+    client: reqwest::Client,
+}
+
+impl BinanceClient {
+    pub fn new(config: BinanceConfig) -> Self {
+        Self {
+            config,
+            client: reqwest::Client::new(),
+        }
+    }
+    
+    pub async fn get_klines(&self, symbol: &str, interval: &str, limit: usize) -> Result<Vec<BinanceKline>, Box<dyn std::error::Error + Send + Sync>> {
+        let url = format!("{}/v3/klines", self.config.base_url());
+        let response = self.client.get(&url)
+            .query(&[
+                ("symbol", symbol),
+                ("interval", interval),
+                ("limit", &limit.to_string()),
+            ])
+            .send()
+            .await?;
+        
+        let data: Vec<Vec<serde_json::Value>> = response.json().await?;
+        
+        let klines: Vec<BinanceKline> = data.iter().map(|k| BinanceKline {
+            open_time: k[0].as_i64().unwrap_or(0),
+            open: k[1].as_str().unwrap_or("0").parse().unwrap_or(0.0),
+            high: k[2].as_str().unwrap_or("0").parse().unwrap_or(0.0),
+            low: k[3].as_str().unwrap_or("0").parse().unwrap_or(0.0),
+            close: k[4].as_str().unwrap_or("0").parse().unwrap_or(0.0),
+            volume: k[5].as_str().unwrap_or("0").parse().unwrap_or(0.0),
+            close_time: k[6].as_i64().unwrap_or(0),
+        }).collect();
+        
+        Ok(klines)
+    }
+    
+    pub async fn get_ticker(&self, symbol: &str) -> Result<BinanceTicker, Box<dyn std::error::Error + Send + Sync>> {
+        let url = format!("{}/v3/ticker/24hr", self.config.base_url());
+        let response = self.client.get(&url)
+            .query(&[("symbol", symbol)])
+            .send()
+            .await?;
+        
+        let data: serde_json::Value = response.json().await?;
+        
+        Ok(BinanceTicker {
+            symbol: data["symbol"].as_str().unwrap_or("").to_string(),
+            last_price: data["lastPrice"].as_str().unwrap_or("0").parse().unwrap_or(0.0),
+            price_change_percent: data["priceChangePercent"].as_str().unwrap_or("0").parse().unwrap_or(0.0),
+            volume: data["volume"].as_str().unwrap_or("0").parse().unwrap_or(0.0),
+        })
+    }
+}

rust-api/src/main.rs

@@ -0,0 +1,227 @@
+use axum::{
+    routing::{get, post},
+    Router, Json, extract::State,
+};
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use chrono::{DateTime, Utc};
+
+mod trading;
+mod binance;
+
+pub use trading::*;
+pub use binance::*;
+
+#[derive(Clone)]
+pub struct AppState {
+    pub config: TradingConfig,
+    pub positions: Arc<Mutex<Vec<Position>>>,
+    pub orders: Arc<Mutex<Vec<Order>>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TradingConfig {
+    pub api_key: String,
+    pub api_secret: String,
+    pub testnet: bool,
+    pub max_position_size: f64,
+    pub stop_loss_percent: f64,
+    pub take_profit_percent: f64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Position {
+    pub id: String,
+    pub symbol: String,
+    pub side: String,
+    pub quantity: f64,
+    pub entry_price: f64,
+    pub current_price: f64,
+    pub pnl: f64,
+    pub opened_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Order {
+    pub id: String,
+    pub symbol: String,
+    pub side: String,
+    pub order_type: String,
+    pub quantity: f64,
+    pub price: Option<f64>,
+    pub status: String,
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct CreateOrderRequest {
+    pub symbol: String,
+    pub side: String,
+    pub quantity: f64,
+    pub price: Option<f64>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ClosePositionRequest {
+    pub position_id: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ApiResponse<T> {
+    pub success: bool,
+    pub data: Option<T>,
+    pub error: Option<String>,
+}
+
+async fn health() -> Json<ApiResponse<String>> {
+    Json(ApiResponse {
+        success: true,
+        data: Some("RapidLiveClient API running".to_string()),
+        error: None,
+    })
+}
+
+async fn get_balance(State(state): State<AppState>) -> Json<ApiResponse<f64>> {
+    let balance = state.config.testnet as i32 as f64 * 10000.0;
+    Json(ApiResponse {
+        success: true,
+        data: Some(balance),
+        error: None,
+    })
+}
+
+async fn get_positions(State(state): State<AppState>) -> Json<ApiResponse<Vec<Position>>> {
+    let positions = state.positions.lock().await.clone();
+    Json(ApiResponse {
+        success: true,
+        data: Some(positions),
+        error: None,
+    })
+}
+
+async fn get_orders(State(state): State<AppState>) -> Json<ApiResponse<Vec<Order>>> {
+    let orders = state.orders.lock().await.clone();
+    Json(ApiResponse {
+        success: true,
+        data: Some(orders),
+        error: None,
+    })
+}
+
+async fn create_order(
+    State(state): State<AppState>,
+    Json(req): Json<CreateOrderRequest>,
+) -> Json<ApiResponse<Order>> {
+    let order = Order {
+        id: format!("ORD-{}", chrono::Utc::now().timestamp_millis()),
+        symbol: req.symbol.clone(),
+        side: req.side.clone(),
+        order_type: if req.price.is_some() { "LIMIT".to_string() } else { "MARKET".to_string() },
+        quantity: req.quantity,
+        price: req.price,
+        status: "pending".to_string(),
+        created_at: Utc::now(),
+    };
+    
+    state.orders.lock().await.push(order.clone());
+    
+    Json(ApiResponse {
+        success: true,
+        data: Some(order),
+        error: None,
+    })
+}
+
+async fn close_position(
+    State(state): State<AppState>,
+    Json(req): Json<ClosePositionRequest>,
+) -> Json<ApiResponse<Position>> {
+    let mut positions = state.positions.lock().await;
+    
+    if let Some(pos) = positions.iter_mut().find(|p| p.id == req.position_id) {
+        let current_price = pos.current_price;
+        let pnl = if pos.side == "BUY" {
+            (current_price - pos.entry_price) * pos.quantity
+        } else {
+            (pos.entry_price - current_price) * pos.quantity
+        };
+        
+        pos.pnl = pnl;
+        
+        Json(ApiResponse {
+            success: true,
+            data: Some(pos.clone()),
+            error: None,
+        })
+    } else {
+        Json(ApiResponse {
+            success: false,
+            data: None,
+            error: Some("Position not found".to_string()),
+        })
+    }
+}
+
+async fn analyze_market(
+    State(state): State<AppState>,
+    Json(req): Json<serde_json::Value>,
+) -> Json<ApiResponse<serde_json::Value>> {
+    let symbol = req.get("symbol")
+        .and_then(|s| s.as_str())
+        .unwrap_or("BTCUSDT");
+    
+    let analysis = serde_json::json!({
+        "symbol": symbol,
+        "recommendation": "BUY",
+        "confidence": 0.75,
+        "reason": "RSI oversold, trend bullish",
+        "entry_price": 50000.0,
+        "stop_loss": 47500.0,
+        "take_profit": 55000.0,
+        "risk_level": "MEDIUM"
+    });
+    
+    Json(ApiResponse {
+        success: true,
+        data: Some(analysis),
+        error: None,
+    })
+}
+
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt::init();
+    
+    let config = TradingConfig {
+        api_key: std::env::var("BINANCE_API_KEY").unwrap_or_default(),
+        api_secret: std::env::var("BINANCE_API_SECRET").unwrap_or_default(),
+        testnet: true,
+        max_position_size: 1000.0,
+        stop_loss_percent: 5.0,
+        take_profit_percent: 10.0,
+    };
+    
+    let state = AppState {
+        config,
+        positions: Arc::new(Mutex::new(Vec::new())),
+        orders: Arc::new(Mutex::new(Vec::new())),
+    };
+    
+    let app = Router::new()
+        .route("/", get(health))
+        .route("/health", get(health))
+        .route("/api/balance", get(get_balance))
+        .route("/api/positions", get(get_positions))
+        .route("/api/orders", get(get_orders))
+        .route("/api/orders", post(create_order))
+        .route("/api/positions/close", post(close_position))
+        .route("/api/analyze", post(analyze_market))
+        .with_state(state);
+    
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
+    
+    tracing::info!("RapidLiveClient API running on http://0.0.0.0:3000");
+    
+    axum::serve(listener, app).await.unwrap();
+}

rust-api/src/trading.rs

@@ -0,0 +1,68 @@
+// Trading module placeholder
+// This would contain Nautilus Trader strategy integration
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StrategyConfig {
+    pub name: String,
+    pub symbols: Vec<String>,
+    pub capital: f64,
+    pub risk_per_trade: f64,
+    pub max_positions: usize,
+}
+
+impl Default for StrategyConfig {
+    fn default() -> Self {
+        Self {
+            name: "RapidAgentStrategy".to_string(),
+            symbols: vec![
+                "BTCUSDT".to_string(),
+                "ETHUSDT".to_string(),
+                "SOLUSDT".to_string(),
+            ],
+            capital: 10000.0,
+            risk_per_trade: 0.02,
+            max_positions: 3,
+        }
+    }
+}
+
+pub struct TradingStrategy {
+    config: StrategyConfig,
+}
+
+impl TradingStrategy {
+    pub fn new(config: StrategyConfig) -> Self {
+        Self { config }
+    }
+    
+    pub fn should_entry(&self, symbol: &str, rsi: f64, trend: &str) -> bool {
+        if rsi < 30.0 && trend == "bullish" {
+            return true;
+        }
+        if rsi < 40.0 && trend == "bullish" {
+            return true;
+        }
+        false
+    }
+    
+    pub fn should_exit(&self, symbol: &str, rsi: f64, pnl_percent: f64) -> bool {
+        if rsi > 70.0 {
+            return true;
+        }
+        if pnl_percent >= self.config.risk_per_trade * 5.0 {
+            return true;
+        }
+        if pnl_percent <= -self.config.risk_per_trade * 2.0 {
+            return true;
+        }
+        false
+    }
+    
+    pub fn calculate_position_size(&self, capital: f64, entry: f64, stop_loss: f64) -> f64 {
+        let risk_amount = capital * self.config.risk_per_trade;
+        let risk_per_unit = (entry - stop_loss).abs() / entry;
+        risk_amount / risk_per_unit
+    }
+}