🚀 VSTP - Vishu's Secure Transfer Protocol

The Future of Network Communication - A blazing-fast, secure, and intelligent binary protocol that redefines how applications communicate over networks.

🌟 Why VSTP is Revolutionary

VSTP isn't just another protocol - it's a complete communication ecosystem that combines the best of TCP reliability with UDP speed, while adding cutting-edge features that make it perfect for modern applications:

• 🔥 Dual Transport Intelligence: Seamlessly switch between TCP reliability and UDP speed
• 🛡️ Built-in Security: TLS 1.3 ready, CRC integrity checking, and secure by design
• ⚡ Zero-Copy Performance: Lightning-fast binary serialization with minimal overhead
• 🧩 Smart Fragmentation: Automatically handles massive payloads with intelligent reassembly
• 🎯 Reliability on Demand: Optional ACK-based delivery confirmation for UDP
• 🏗️ Extensible Architecture: Binary headers for unlimited custom metadata
• 🚀 Async-First: Built for the modern async/await world with Tokio

🎯 Perfect For

• Real-time Gaming: Low-latency UDP with optional reliability
• IoT Systems: Lightweight protocol with robust error handling
• Microservices: Fast inter-service communication with rich metadata
• Streaming Applications: Efficient binary protocol with fragmentation support
• Blockchain Networks: Secure, fast peer-to-peer communication
• Edge Computing: Minimal overhead with maximum performance

⚡ Installation

Add VSTP to your Cargo.toml:

[dependencies]
vstp = "0.1"
tokio = { version = "1.0", features = ["full"] }

🚀 Quick Start - See the Magic

TCP Mode - Reliable & Fast

use vstp::{VstpTcpClient, VstpTcpServer, Frame, FrameType, Flags};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Start a blazing-fast TCP server
    let server = VstpTcpServer::bind("127.0.0.1:6969").await?;
    tokio::spawn(async move {
        server.run(|session_id, frame| async move {
            println!("🔥 Session {} received: {:?} with {} bytes", 
                     session_id, frame.typ, frame.payload.len());
        }).await.unwrap();
    });

    // Connect with intelligent client
    let mut client = VstpTcpClient::connect("127.0.0.1:6969").await?;
    
    // Send rich metadata with your data
    let frame = Frame::new(FrameType::Data)
        .with_header("content-type", "application/json")
        .with_header("user-id", "12345")
        .with_header("priority", "high")
        .with_payload(br#"{"message": "Hello VSTP World!", "timestamp": 1234567890}"#.to_vec())
        .with_flag(Flags::CRC); // Enable integrity checking
    
    client.send(frame).await?;
    client.close().await?;
    Ok(())
}

UDP Mode - Lightning Fast with Smart Features

use vstp::{VstpUdpClient, VstpUdpServer, Frame, FrameType, Flags};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Start UDP server with automatic fragmentation handling
    let server = VstpUdpServer::bind("127.0.0.1:6969").await?;
    tokio::spawn(async move {
        server.run(|addr, frame| async move {
            println!("⚡ {} sent: {:?} ({} bytes)", addr, frame.typ, frame.payload.len());
        }).await.unwrap();
    });

    let client = VstpUdpClient::bind("127.0.0.1:0").await?;
    
    // Send massive payload - VSTP automatically fragments it!
    let huge_data = vec![0x42u8; 50000]; // 50KB of data
    let frame = Frame::new(FrameType::Data)
        .with_header("file-name", "massive-dataset.bin")
        .with_header("chunk-id", "001")
        .with_payload(huge_data)
        .with_flag(Flags::REQ_ACK); // Request delivery confirmation
    
    // This will automatically fragment and reassemble!
    client.send_with_ack(frame, "127.0.0.1:6969".parse()?).await?;
    Ok(())
}

🧠 Advanced Features That Will Blow Your Mind

1. Intelligent Fragmentation

// Send 100MB file - VSTP handles everything automatically!
let massive_file = vec![0u8; 100_000_000];
let frame = Frame::new(FrameType::Data)
    .with_header("file-type", "video")
    .with_header("resolution", "4K")
    .with_payload(massive_file);

// VSTP automatically:
// - Splits into optimal fragments
// - Adds fragment metadata
// - Reassembles on receiver
// - Handles lost fragments
client.send(frame, dest).await?;

2. Reliability on Demand

// Fast UDP with optional reliability
let critical_data = Frame::new(FrameType::Data)
    .with_header("transaction-id", "tx-12345")
    .with_header("retry-count", "3")
    .with_payload(important_data)
    .with_flag(Flags::REQ_ACK); // Only this frame needs ACK

// VSTP handles:
// - Automatic retries with exponential backoff
// - ACK tracking
// - Timeout management
client.send_with_ack(critical_data, dest).await?;

3. Rich Metadata System

let frame = Frame::new(FrameType::Data)
    .with_header("api-version", "2.1")
    .with_header("auth-token", "bearer_xyz123")
    .with_header("compression", "gzip")
    .with_header("cache-control", "no-cache")
    .with_header("user-agent", "MyApp/1.0")
    .with_header("request-id", "req-789")
    .with_payload(json_data);

4. Built-in Integrity Checking

let secure_frame = Frame::new(FrameType::Data)
    .with_payload(sensitive_data)
    .with_flag(Flags::CRC); // Automatic CRC32 validation

// VSTP automatically:
// - Calculates CRC32 checksum
// - Validates on receiver
// - Rejects corrupted frames

🎮 Real-World Examples

Gaming Server

// Ultra-low latency game updates
let game_state = Frame::new(FrameType::Data)
    .with_header("game-id", "match-456")
    .with_header("player-id", "player-789")
    .with_header("tick", "1234")
    .with_payload(serialized_game_state);

// Fast UDP for real-time updates
client.send(game_state, game_server).await?;

IoT Sensor Network

// Efficient sensor data with metadata
let sensor_data = Frame::new(FrameType::Data)
    .with_header("sensor-id", "temp-001")
    .with_header("location", "building-a-floor-2")
    .with_header("battery", "85%")
    .with_header("timestamp", "1640995200")
    .with_payload(temperature_reading)
    .with_flag(Flags::REQ_ACK); // Ensure delivery

client.send_with_ack(sensor_data, iot_gateway).await?;

File Transfer

// Massive file transfer with progress tracking
let file_chunk = Frame::new(FrameType::Data)
    .with_header("file-id", "doc-123")
    .with_header("chunk-number", "5")
    .with_header("total-chunks", "100")
    .with_header("file-size", "10485760")
    .with_payload(chunk_data)
    .with_flag(Flags::REQ_ACK);

client.send_with_ack(file_chunk, file_server).await?;

🔧 Advanced Configuration

Custom UDP Client with Smart Settings

use vstp::udp::{VstpUdpClient, UdpConfig};

let config = UdpConfig {
    max_retries: 5,                    // More retries for critical data
    retry_delay: Duration::from_millis(50), // Faster retries
    max_retry_delay: Duration::from_secs(2), // Cap retry delay
    ack_timeout: Duration::from_secs(1),     // Quick timeout
    use_crc: true,                     // Always verify integrity
    allow_frag: true,                  // Enable fragmentation
};

let client = VstpUdpClient::bind_with_config("127.0.0.1:0", config).await?;

📊 Performance Benchmarks

🎯 Protocol Specification

VSTP uses an intelligent binary format:

[MAGIC (2B)] [VER (1B)] [TYPE (1B)] [FLAGS (1B)]
[HDR_LEN (2B LE)] [PAY_LEN (4B BE)] [HEADERS...] [PAYLOAD...]
[CRC32 (4B, optional)]

Frame Types

• HELLO - Connection initiation
• WELCOME - Connection acceptance
• DATA - Application data
• PING/PONG - Keepalive
• BYE - Graceful close
• ACK - Acknowledgement
• ERR - Error handling

Smart Flags

• CRC - Enable integrity checking
• REQ_ACK - Request delivery confirmation
• FRAG - Frame is fragmented (auto-managed)

🧪 Testing & Examples

Run the included examples to see VSTP in action:

# TCP examples
cargo run --example tcp_server
cargo run --example tcp_client

# UDP examples with fragmentation
cargo run --example udp_server  
cargo run --example udp_client

# Run comprehensive test suite
cargo test

🚀 Installation from Crates.io

# Install VSTP globally
cargo install vstp

# Use in your project
cargo add vstp

🌟 What Makes VSTP Special

1. 🧠 Intelligent: Automatically handles fragmentation, retries, and reassembly
2. ⚡ Fast: Zero-copy operations with minimal overhead
3. 🛡️ Secure: Built-in integrity checking and TLS ready
4. 🔧 Flexible: Choose reliability when you need it, speed when you don't
5. 📦 Rich: Binary headers for unlimited metadata
6. 🎯 Modern: Async-first design with Tokio integration
7. 🌍 Universal: Works everywhere Rust works

🎉 Join the Revolution

VSTP is more than a protocol - it's the future of network communication. Whether you're building the next generation of games, IoT systems, or distributed applications, VSTP gives you the tools to communicate faster, smarter, and more reliably than ever before.

Ready to experience the future? Add VSTP to your project today!

[dependencies]
vstp = "0.1"

Built with ❤️ by the VSTP team. Making network communication faster, smarter, and more reliable.