Integración Nativa Core (Rust)

Aprende a conectar nodos usando el lenguaje nativo del Protocolo Orzatty. Sin intermediarios, velocidad binaria pura.

1

Instalación en tu proyecto

El Protocolo Orzatty (PO) se distribuye como un paquete llamado 'Crate' en el ecosistema Rust. Para usarlo, simplemente debes agregarlo a la mochila de herramientas de tu proyecto, que se llama `Cargo.toml`.

Abre el archivo `Cargo.toml` de tu proyecto y añade estas líneas justo debajo de `[dependencies]`.

# Cargo.toml
[dependencies]
po-node = { git = "https://github.com/orzattyholding/po.git" }
tokio = { version = "1.0", features = ["full"] }

💡 Para que lo entiendas súper fácil: Imagina que estás armando un LEGO impresionante. `Cargo.toml` es la lista de compras que le das a tu mamá. Le estás pidiendo la caja de fichas "po-node" (que trae todas las funciones para hablar con el protocolo) y "tokio" (que es el motorcito que permite hacer varias cosas al mismo tiempo sin trabarse).

2

Iniciar un Servidor (Crear la puerta)

Para que dos computadoras se hablen, una tiene que estar escuchando (como un oyente de radio esperando una llamada). En PO, crear un servidor toma exactamente 1 línea de código.

Crea un archivo llamado `src/server.rs` y pon este código:

use po_node::Po;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Abrimos el puerto 4433. ¡Ya estamos escuchando!
    let mut server = Po::bind(4433).await?;
    println!("Servidor Orzatty escuchando en modo E2EE...");

    // 2. Nos quedamos en un ciclo eterno esperando que lleguen paquetes
    while let Some((canal, datos)) = server.recv().await? {
        let mensaje_texto = String::from_utf8_lossy(&datos);
        println!("¡Recibimos un paquete!: {}", mensaje_texto);
    }
    
    Ok(())
}

💡 Para que lo entiendas súper fácil: Imagina que abriste la puerta número 4433 de tu casa. Te quedas sentado esperando a que un cartero te lance un sobre negro blindado por debajo de la puerta (`server.recv()`). El protocolo abre el candado cripotográfico, saca el papelito de adentro y lo lee.

3

Conectar un Cliente (Lanzar el misil de datos)

Ahora que el servidor está escuchando en la puerta 4433, necesitamos que otra computadora (o un programa distinto) llame a esa puerta para establecer el túnel secreto cifrado. ¡Felicidades! A diferencia de los sistemas tradicionales como WebSockets, con Orzatty Protocol tú NO creas candados manuales. La matemática ED25519 crea el candado y la llave automáticamente.

Crea un archivo llamado `src/client.rs` y pon esto:

use po_node::Po;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Conectarnos a la computadora que está en nuestro mismo cuarto (127.0.0.1)
    let mut client = Po::connect("127.0.0.1:4433").await?;
    
    // 2. ¡Lanzar la data cifrada!
    let contenido = b"Este es un secreto corporativo de Orzatty";
    client.send(contenido).await?;
    
    println!("¡Paquete enviado a hiper-velocidad!");
    Ok(())
}

💡 Para que lo entiendas súper fácil: Piensa que `Po::connect` manda construir un tubo de acero impenetrable desde tu casa hasta la casa 127.0.0.1. Por fuera el tubo se ve gris, nadie sabe qué hay adentro. Cuando usas `client.send()`, metes una esfera por el tubo que viaja rapidísimo. Solo el que está del otro lado sabe cómo abrir la esfera.

4

Modo "Batch" (Para enviar 10 Mil Mensajes por Segundo) 🚀

Si eres un Arquitecto de Sistemas intentando escalar, `send` normal cifrará 1 por 1 los mensajes. Si vas a inundar la red con miles de paquetes pequeños (Telemetría de juegos, IA), tienes que usar `send_batch()`.

Esto junta muchos paquetes chiquitos, los mete todos en una gran caja fuerte matemática de ChaCha20, cifra la caja enorme una sola vez y la manda como una bestia de carga.

use po_node::Po;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = Po::connect("127.0.0.1:4433").await?;
    
    // Creamos 5,000 mensajitos pequeños
    let mut batch_de_mensajes = Vec::new();
    for _ in 0..5000 {
        batch_de_mensajes.push(b"telemetria_diminuta".as_slice());
    }

    // Usamos el optimizador! (Aumento de velocidad de 4.8x)
    client.send_batch(&batch_de_mensajes).await?;
    
    Ok(())
}

💡 Para que lo entiendas súper fácil: Imagina que tienes 5,000 chocolates y le vas a poner una envoltura y un moño a cada uno. Tardarías toda la vida. `send_batch` mete los 5,000 chcolates en una caja de cartón gigante, le pone un solo moño gigante a la caja y la lanza de un solo tiro. ¡Menos trabajo para tu computadora, más velocidad para ti!