Cliente Rust para IG.com - SDK open source para trading algorítmico

Al desarrollar sistemas de trading algorítmico en Rust para un cliente del sector financiero, me encontré con una carencia fundamental: no existía ninguna biblioteca cliente en Rust para IG.com, uno de los brokers líderes en CFDs, opciones y futuros con presencia global. En lugar de implementar una solución propietaria cerrada, desarrollé un SDK cliente completo en Rust y lo publiqué como software open source para beneficio de toda la comunidad de desarrolladores interesados en finanzas cuantitativas y trading algorítmico.

El desafío: integración profesional con IG.com desde Rust

¿Qué es IG.com?

IG.com (IG Group) es un broker global de trading en línea fundado en 1974, con más de 300.000 clientes activos y regulación en múltiples jurisdicciones (FCA, ASIC, MAS, entre otras). Ofrece acceso a más de 17.000 mercados globales:

Productos financieros:

• CFDs (Contratos por Diferencia) sobre índices, acciones, materias primas, criptomonedas
• Opciones y opciones barrier
• Futuros
• Forex con spreads competitivos
• Turbos y warrants

Casos de uso principales:

• Trading algorítmico: ejecución automatizada de estrategias cuantitativas
• Gestión de carteras: administración programática de posiciones
• Análisis de mercado: acceso a datos históricos y en tiempo real
• Backtesting: validación de estrategias con datos reales
• Trading de alta frecuencia: ejecución rápida de órdenes

API de IG.com:

• API REST completa para gestión de cuentas, órdenes y consultas.
• Streaming API basada en Lightstreamer para datos de mercado en tiempo real.
• Documentación técnica exhaustiva con ejemplos en múltiples lenguajes.
• Entorno sandbox para pruebas antes de operar en real.

La carencia en el ecosistema Rust

IG.com proporciona bibliotecas cliente oficiales y ejemplos para:

• ✅ Java
• ✅ C# (.NET)
• ✅ Python
• ✅ JavaScript/TypeScript
• ❌ Rust: NINGUNA

El problema: Rust se está consolidando como el lenguaje preferido para sistemas de trading de alto rendimiento debido a:

• Rendimiento comparable a C/C++ sin sacrificar seguridad.
• Ausencia de recolector de basura (sin pausas impredecibles).
• Concurrencia segura sin race conditions.
• Abstracciones de costo cero.
• Ecosistema moderno con herramientas excelentes.

Sin embargo, sin un cliente Rust para IG.com, los desarrolladores debían elegir entre:

1. Usar otro lenguaje para la integración con IG (añadiendo complejidad al stack)
2. Implementar un cliente desde cero (costoso, consumía semanas de desarrollo)
3. Cambiar de broker (perdiendo las ventajas de IG.com)
4. Abandonar Rust para este proyecto (perdiendo sus beneficios)

Ninguna opción era aceptable para un sistema profesional que requería las garantías de Rust y la robustez de IG.com.

La solución: un SDK completo en Rust

Desarrollé ig_trading_api, un SDK completo en Rust que implementa tanto la API REST como la API de Streaming de IG.com. La biblioteca proporciona una interfaz type-safe y asíncrona que resulta natural para desarrolladores Rust mientras mantiene compatibilidad total con la plataforma de IG.

Arquitectura y decisiones de diseño

Tecnologías principales:

Componente	Tecnología	Propósito
Runtime asíncrono	Tokio	I/O no bloqueante y manejo concurrente
Cliente HTTP	reqwest	Comunicación con REST API
Streaming	lightstreamer-client	Datos de mercado en tiempo real
Serialización	serde/serde_json	Manejo type-safe de datos
Configuración	serde_yaml	Gestión de credenciales y configuración
Validación	regex	Validación de formatos y patrones

Decisiones técnicas clave

1. Arquitectura modular

El SDK está organizado en módulos claramente separados:

Estructura del código:

ig_trading_api/
├── rest_client.rs    # Cliente REST principal
├── rest_api.rs       # Endpoints de la API REST
├── rest_models.rs    # Modelos de datos type-safe
├── streaming_api.rs  # API de streaming en tiempo real
├── common.rs         # Utilidades compartidas
└── rest_regex.rs     # Validación de patrones

Beneficios:

• Separación clara de responsabilidades.
• Facilita mantenimiento y extensiones.
• Permite uso selectivo de funcionalidades.
• Testing independiente de módulos.

2. Gestión type-safe de la API REST

Todos los endpoints de IG.com están modelados con tipos Rust que garantizan corrección en tiempo de compilación:

// Modelos de datos con validación automática
#[derive(Debug, Serialize, Deserialize)]
pub struct AccountInfo {
    pub account_id: String,
    pub account_name: String,
    pub balance: Balance,
    pub currency: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Position {
    pub deal_id: String,
    pub epic: String,
    pub direction: Direction,
    pub size: f64,
    pub level: f64,
}

Ventajas:

• Prevención de errores en tiempo de compilación.
• Autocompletado IDE completo.
• Refactorización segura.
• Documentación inline automática.

3. Autenticación y gestión de sesión

Sistema robusto de autenticación con manejo automático de tokens:

pub struct IGRestClient {
    config: Config,
    client: reqwest::Client,
    auth_headers: Option<AuthHeaders>,
}

impl IGRestClient {
    pub async fn authenticate(&mut self) -> Result<(), IGError> {
        // Autenticación con API key y credenciales
        // Gestión automática de headers CST y X-SECURITY-TOKEN
        // Renovación automática de sesión si expira
    }
}

Características:

• Login automático con credenciales desde archivo YAML.
• Renovación transparente de tokens expirados.
• Manejo de múltiples cuentas (real/demo).
• Gestión segura de secretos.

Funcionalidades implementadas

1. API REST completa

Gestión de cuentas:

• Obtención de información de cuenta.
• Consulta de balances y márgenes.
• Listado de cuentas disponibles.
• Cambio entre cuentas (real/demo).

Gestión de órdenes y posiciones:

• Creación de nuevas posiciones (BUY/SELL).
• Modificación de posiciones existentes.
• Cierre parcial o total de posiciones.
• Configuración de stops y limits.
• Consulta de posiciones abiertas.
• Historial de operaciones.

Datos de mercado:

• Búsqueda de instrumentos por nombre.
• Detalles completos de instrumentos (épicos, spreads, horarios).
• Precios en tiempo real mediante polling.
• Datos históricos (velas OHLC).
• Información de mercado (abierto/cerrado, restricciones).

Órdenes pendientes:

• Creación de órdenes limitadas.
• Configuración de órdenes stop.
• Modificación de órdenes existentes.
• Cancelación de órdenes.
• Consulta de órdenes activas.

2. Streaming API en tiempo real

Integración completa con Lightstreamer para datos en vivo:

Streaming de precios:

• Suscripción a precios bid/ask en tiempo real.
• Actualización continua de múltiples instrumentos.
• Latencia mínima (actualizaciones en milisegundos).
• Manejo automático de reconexión.

Streaming de cuentas:

• Monitorización de cambios en el balance.
• Notificaciones de P&L en tiempo real.
• Alertas de margin calls.
• Eventos de órdenes ejecutadas.

// Ejemplo de suscripción a streaming
pub async fn subscribe_to_market(
    &self,
    epic: &str,
) -> Result<(), StreamingError> {
    let subscription = create_price_subscription(epic);
    self.lightstreamer_client
        .subscribe(subscription)
        .await?;
    Ok(())
}

3. Configuración flexible

Sistema de configuración mediante archivo YAML:

ig_api:
  base_url: "https://demo-api.ig.com/gateway/deal"
  api_key: "your-api-key"
  username: "your-username"
  password: "your-password"
  account_id: "your-account"
  
streaming:
  adapter_set: "DEFAULT"
  lightstreamer_endpoint: "https://demo-apd.marketdatasys.com"

Beneficios:

• Separación de código y configuración.
• Múltiples entornos (demo/real).
• Gestión segura de credenciales.
• Fácil configuración para CI/CD.

4. Características listas para producción

Aplicación real: sistema de trading algorítmico

Este SDK se desarrolló como parte de un sistema de trading algorítmico profesional que requería:

Requisitos del sistema:

• Ejecución automatizada de estrategias cuantitativas complejas.
• Monitorización continua de múltiples instrumentos financieros.
• Latencia mínima en la ejecución de órdenes.
• Gestión de riesgo en tiempo real.
• Alta confiabilidad y recuperación ante fallos.
• Logging exhaustivo para auditoría.

Resultados: El cliente Rust de IG.com impulsa exitosamente operaciones de trading automatizado en producción, permitiendo:

• Ejecución de estrategias multi-instrumento.
• Gestión automática de stops dinámicos.
• Rebalanceo de posiciones según señales cuantitativas.
• Monitorización de P&L en tiempo real.
• Operación 24/7 con supervisión mínima.

Contribución open source

¿Por qué open source?

Aunque se desarrolló para un cliente confidencial del sector financiero, tomé la decisión estratégica de publicar esta biblioteca como software open source por razones fundamentales:

1. Beneficio para la comunidad fintech en Rust

• Llena un vacío crítico para desarrolladores de sistemas de trading en Rust.
• Facilita la adopción de Rust en finanzas cuantitativas.
• Reduce barreras de entrada para nuevos proyectos.
• Evita duplicación de esfuerzos entre equipos.

2. Calidad mediante colaboración

• La revisión de código de la comunidad detecta bugs y mejora la calidad.
• Contribuciones de otros desarrolladores enriquecen la funcionalidad.
• Testing más amplio en escenarios diversos.
• Mejora continua basada en feedback real.

3. Avance del ecosistema Rust

• Demuestra la viabilidad de Rust para finanzas profesionales.
• Establece patrones y mejores prácticas para APIs financieras.
• Atrae talento y proyectos al ecosistema Rust.
• Fomenta colaboración entre sectores (finanzas + open source).

4. Transparencia y confianza

• El código abierto permite auditoría completa.
• La comunidad puede verificar la seguridad.
• Sin “cajas negras” en código crítico financiero.

Publicación y disponibilidad

Publicado en crates.io:

• Paquete: ig_trading_api.
• Instalación: cargo add ig_trading_api.
• Documentación: Incluida en el repositorio GitHub.

Repositorio open source:

• GitHub: github.com/daniloaz/ig-trading-api.
• Licencia: GPL-3.0.
• Desarrollo activo.
• Contribuciones bienvenidas.
• Issues y pull requests abiertos.

Adopción de la comunidad:

La biblioteca ha sido adoptada por desarrolladores de la comunidad Rust interesados en trading algorítmico y finanzas cuantitativas:

Ejemplo de uso básico

Aquí hay un ejemplo que demuestra las capacidades principales de la biblioteca:

use ig_trading_api::rest_client::IGRestClient;
use ig_trading_api::rest_models::{Direction, OrderType};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Crear cliente y autenticar
    let mut client = IGRestClient::new("config.yaml")?;
    client.authenticate().await?;
    
    // Obtener información de cuenta
    let account = client.get_account_info().await?;
    println!("Balance: {} {}", account.balance.available, account.currency);
    
    // Buscar un instrumento
    let instruments = client.search_markets("EUR/USD").await?;
    let epic = &instruments[0].epic;
    
    // Abrir posición
    let position = client.create_position(
        epic,
        Direction::Buy,
        1.0,  // tamaño
        OrderType::Market,
        None, // stop loss
        None, // take profit
    ).await?;
    
    println!("Posición abierta: {}", position.deal_id);
    
    // Consultar posiciones abiertas
    let positions = client.get_positions().await?;
    for pos in positions {
        println!("Epic: {}, P&L: {}", pos.epic, pos.profit);
    }
    
    Ok(())
}

Características clave demostradas:

• Autenticación simple.
• API intuitiva y expresiva.
• Manejo de errores con Result.
• Soporte completo para async/await.
• Type safety en todas las operaciones.

Logros técnicos

Desarrollo futuro

La biblioteca proporciona una base sólida con oportunidades de mejora:

Estado actual (v0.2.x):

• Implementación completa de REST API.
• Streaming API funcional con Lightstreamer.
• Gestión de autenticación y sesión.
• Operaciones CRUD sobre posiciones y órdenes.
• Estabilidad en producción verificada.

Posibles mejoras futuras:

• Ampliación de cobertura de endpoints.
• Mejoras en el manejo de errores y retry logic.
• Optimizaciones de performance para HFT.
• Soporte para más tipos de órdenes especializadas.
• Testing automatizado más exhaustivo.
• Ejemplos de estrategias algorítmicas.
• Integración con frameworks de backtesting.

Las contribuciones de la comunidad son bienvenidas para cualquier mejora o extensión.

Conclusión

El Cliente Rust para IG.com representa una contribución estratégica al ecosistema Rust financiero, permitiendo a desarrolladores construir sistemas de trading algorítmico profesionales con uno de los brokers más respetados de la industria. Al publicar esta biblioteca como software open source, he ayudado a cerrar la brecha entre las capacidades de Rust y las plataformas de trading establecidas.

Este proyecto demuestra:

• Profundidad técnica en APIs financieras complejas y Rust asíncrono
• Visión estratégica al identificar y resolver carencias del ecosistema
• Compromiso con la comunidad mediante contribución open source
• Experiencia real en sistemas financieros de producción con capital real

La biblioteca se mantiene activamente y está lista para cualquier proyecto que requiera integración con IG.com desde Rust, ya sea trading algorítmico, backtesting, análisis cuantitativo o gestión de carteras.

---