BitSage Network - Rust Node

High-performance Rust node for the BitSage Network, featuring Obelysk Protocol integration with GPU-accelerated zero-knowledge proofs.

🚀 Key Features

Obelysk Protocol

• Verifiable Computation - Prove that GPU computations ran correctly
• TEE Integration - Data encrypted in Trusted Execution Environment
• GPU-Accelerated Proving - 54-174x faster than CPU SIMD
• True Multi-GPU - Thread-safe parallel execution (193% scaling!)
• Minimal Proof Output - Only 32-byte attestation returned

🔥 Performance (Verified)

Single GPU (H100 80GB)

Proof Size	GPU Compute	SIMD Estimate	Speedup
2^18 (8MB)	2.42ms	132ms	54.6x ✓
2^20 (32MB)	5.71ms	560ms	98.2x ✓
2^22 (64MB)	17.73ms	2.22s	125.2x ✓
2^23 (64MB)	25.83ms	4.5s	174.2x ✓

Multi-GPU (4x H100, Verified ✓)

Metric	Value
Throughput	1,237 proofs/sec 🚀
Per-proof time	0.81ms
Scaling efficiency	193% (super-linear!)
Hourly capacity	4.45 million proofs
Daily capacity	107 million proofs

GPU Comparison

GPU	Speedup	Proofs/sec	Status
A100 80GB	45-130x	127	Verified ✓
H100 80GB	55-174x	150	Verified ✓
4x H100	55-174x	1,237	Verified ✓

Cost Analysis

Configuration	Proofs/hr	Cost per Proof
A100 80GB	457,200	$0.0000033
H100 80GB	540,000	$0.0000056
4x H100	4,453,200	$0.0000026

📦 Architecture

rust-node/
├── src/
│   ├── obelysk/              # Obelysk Protocol
│   │   ├── prover.rs         # ZK proof generation
│   │   ├── vm.rs             # Obelysk Virtual Machine
│   │   └── stwo_adapter.rs   # Stwo GPU integration
│   ├── coordinator/          # Job coordination
│   ├── network/              # P2P networking
│   ├── blockchain/           # Starknet integration
│   └── compute/              # Job execution
└── libs/stwo/                # GPU-accelerated Stwo fork

🛠️ Quick Start

Prerequisites

• Rust nightly
• CUDA Toolkit 12.x (for GPU acceleration)
• NVIDIA GPU (H100 recommended for best performance)

Build

# Standard build (CPU only)
cargo build --release

# Single GPU
cargo build --release --features cuda

# Multi-GPU
cargo build --release --features cuda,multi-gpu

Run GPU Benchmark

cd libs/stwo

# Production benchmark
cargo run --example obelysk_production_benchmark --features cuda-runtime --release

# H100 comprehensive (all proof sizes)
cargo run --example h100_comprehensive_benchmark --features cuda-runtime --release

# True multi-GPU benchmark (1,237 proofs/sec)
cargo run --example true_multi_gpu_benchmark --features cuda-runtime --release

📊 How Obelysk Works

┌─────────────────────────────────────────────────────────────────┐
│                    Obelysk Proof Pipeline                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  1. Client submits encrypted workload                          │
│                    │                                            │
│                    ▼                                            │
│  2. Data uploaded to GPU (stays in TEE)                        │
│                    │                                            │
│                    ▼                                            │
│  3. GPU computes: FFT → FRI → Merkle                           │
│     (Data NEVER leaves GPU - 174x faster!)                      │
│                    │                                            │
│                    ▼                                            │
│  4. 32-byte proof/attestation returned                         │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Multi-GPU Architecture (193% Scaling!)

┌─────────────────────────────────────────────────────────────────────────────┐
│                    MultiGpuExecutorPool (Thread-Safe)                        │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│   ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐          │
│   │ Arc<Mutex<Ctx>>  │  │ Arc<Mutex<Ctx>>  │  │ Arc<Mutex<Ctx>>  │  ...     │
│   │     GPU 0        │  │     GPU 1        │  │     GPU 2        │          │
│   │  - Executor      │  │  - Executor      │  │  - Executor      │          │
│   │  - TwiddleCache  │  │  - TwiddleCache  │  │  - TwiddleCache  │          │
│   └──────────────────┘  └──────────────────┘  └──────────────────┘          │
│           │                     │                     │                      │
│           ▼                     ▼                     ▼                      │
│   ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐          │
│   │  Thread 0        │  │  Thread 1        │  │  Thread 2        │          │
│   │  Proofs 0,4,8,12 │  │  Proofs 1,5,9,13 │  │  Proofs 2,6,10,14│          │
│   └──────────────────┘  └──────────────────┘  └──────────────────┘          │
│                                                                              │
│   Result: 1,237 proofs/sec | 4.45M proofs/hour | 107M proofs/day            │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘

Why 193% Scaling Efficiency?

Factor	Impact
Pre-warmed twiddles	Eliminates ~87ms init overhead
True parallelism	Each GPU has own executor
No contention	Thread-safe Arc<Mutex<>> per GPU
H100 performance	Faster than conservative baseline

🔧 Configuration

Environment Variables

# Blockchain
STARKNET_RPC_URL=https://starknet-sepolia.public.blastapi.io
STARKNET_PRIVATE_KEY=0x...

# GPU
CUDA_VISIBLE_DEVICES=0,1,2,3  # For multi-GPU

Config File (config/coordinator.toml)

[server]
port = 8080
host = "0.0.0.0"

[gpu]
enabled = true
device_ids = [0, 1, 2, 3]  # Multi-GPU
mode = "throughput"  # or "distributed"

🧪 Testing

# All tests
cargo test

# GPU integration tests
cargo test --features cuda gpu_backend

# Multi-GPU tests
cargo test --features cuda,multi-gpu multi_gpu

📝 API Endpoints

Health

• GET /health - Node health status
• GET /gpu/status - GPU availability and stats

Jobs

• POST /jobs - Submit new job
• GET /jobs/:id - Get job status
• GET /jobs/:id/proof - Get 32-byte proof

Workers

• POST /workers/register - Register GPU worker
• GET /workers - List workers with GPU info

🔗 Related Repositories

• stwo-gpu - GPU-accelerated Stwo prover
• BitSage-Cairo-Smart-Contracts - Cairo contracts
• BitSage-WebApp - Web frontend

📄 License

MIT License - see LICENSE for details.

---

Built by BitSage Network

Powering verifiable computation with GPU-accelerated ZK proofs

🚀 Verified: 1,237 proofs/sec on 4x H100 | 107M proofs/day