hicon-consensus/README.md

Node.js bindings for HiCon hybrid consensus algorithm

# HiCon: Algoritmo de Consenso Híbrido CCR-CCC

[![Rust Version](https://img.shields.io/badge/rust-1.70+-blue.svg)](https://www.rust-lang.org/)
[![NPM Version](https://img.shields.io/npm/v/hicon-consensus)](https://www.npmjs.com/package/hicon-consensus)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

Un algoritmo de consenso distribuido de alto rendimiento que combina Consenso por Redundancia de Capas Cruzadas (CCR) y Consenso por Comunicación de Capas Cruzadas (CCC) para lograr mejor escalabilidad, tolerancia a fallos y rendimiento.

## Características

- **Híbrido CCR-CCC**: Combina dos enfoques complementarios de consenso para mayor resistencia
- **Alto rendimiento**: Optimizado para alto throughput y baja latencia
- **Tolerancia a fallos**: Diseñado para ser resistente a fallos de nodos
- **Escalabilidad**: Funciona eficientemente en clusters grandes
- **Criptografía post-cuántica**: Implementación preparada para amenazas cuánticas
- **Bindings para Node.js**: API fácil de usar para aplicaciones JavaScript

## Uso en Rust

Para usar HiCon en proyectos Rust, añade esto a tu `Cargo.toml`:

```toml
[dependencies]
hybridconsensus = "0.1.0"
```

Ejemplo básico:

```rust
use hybridconsensus::node::Node;
use hybridconsensus::network::NetworkManager;
use hybridconsensus::crypto::CryptoManager;
use hybridconsensus::metrics::MetricsCollector;
use hybridconsensus::sharding::ShardManager;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Crear componentes necesarios
    let network_manager = Arc::new(NetworkManager::default());
    let crypto_manager = Arc::new(CryptoManager::new());
    let metrics_collector = Arc::new(MetricsCollector::new());
    let shard_manager = Arc::new(ShardManager::new(10));

    // Crear y configurar nodo
    let node = Node::new(
        "node-1".to_string(),
        network_manager,
        shard_manager,
        crypto_manager,
        metrics_collector,
    );

    // Iniciar el nodo
    tokio::spawn(async move {
        if let Err(e) = node.run().await {
            eprintln!("Error running node: {:?}", e);
        }
    });

    // Mantener el programa ejecutándose
    tokio::signal::ctrl_c().await?;
    println!("Shutting down...");

    Ok(())
}
```

## Uso en Node.js

Para usar HiCon en proyectos Node.js, instala el paquete:

```bash
npm install hicon-consensus
```

Ejemplo básico:

```javascript
const { createNode } = require('hicon-consensus');

async function main() {
    // Crear y configurar nodo
    const node = createNode({
        id: 'node-1',
        logPath: './data/node1',
        redundancyFactor: 3,
        enableEncryption: true
    });
    
    // Escuchar eventos
    node.on('stateChange', (oldState, newState) => {
        console.log(`Estado cambiado: ${oldState} -> ${newState}`);
    });
    
    // Iniciar nodo y conectar a peers
    await node.start(['node-2', 'node-3', 'node-4']);
    
    // Proponer un valor
    try {
        const result = await node.propose(JSON.stringify({ key: 'test-key', value: 'test-value' }));
        console.log(`Consenso alcanzado: ${result.success}, término: ${result.term}, índice: ${result.index}`);
    } catch (error) {
        console.error('Error al proponer valor:', error);
    }
    
    // Al finalizar
    process.on('SIGINT', async () => {
        await node.stop();
        process.exit(0);
    });
}

main().catch(console.error);
```

Para ejemplos más detallados, consulta la [documentación](docs/) y [ejemplos](examples/).

## Requisitos de sistema

- Rust 1.70 o superior
- Node.js 14.0 o superior (para bindings de JavaScript)
- Sistema operativo: Linux, macOS, Windows (todos x64/arm64)

## Compilar desde código fuente

```bash
# Clonar el repositorio
git clone https://github.com/osvalois/hicon.git
cd hicon

# Compilar la biblioteca Rust
cargo build --release

# Compilar los bindings de Node.js
npm install
npm run build
```

## Documentación

- [Arquitectura](ARCHITECTURE.md) - Visión general de la arquitectura del sistema
- [Ejemplos](examples/) - Código de ejemplo para Rust y Node.js
- [API Rust](docs/rust-api.md) - Documentación de la API de Rust
- [API JavaScript](docs/js-api.md) - Documentación de la API de JavaScript

## Contribuir

Las contribuciones son bienvenidas. Por favor, lee [CONTRIBUTING.md](CONTRIBUTING.md) para obtener detalles sobre nuestro proceso de envío de pull requests.

## Licencia

Este proyecto está licenciado bajo la Licencia MIT - ver el archivo [LICENSE](LICENSE) para más detalles.