Zolvency - Zero-Knowledge Solvency Layer

After extracting authenticated financial data via zkTLS, we face a second challenge: computing a credit score without revealing the input data or intermediate calculations. This requires executing arbitrary programs (written in high-level languages like Rust) and generating zero-knowledge proofs of correct execution. Enter zkVMs: Zero-Knowledge Virtual Machines.

Why General-Purpose Computation Matters

Traditional zkSNARK circuits (written in languages like Circom) require expressing all logic as arithmetic constraints over finite fields—a tedious and error-prone process. Credit scoring involves complex operations: parsing HTML, summing invoice values, calculating EBITDA, applying risk models with dozens of parameters. Implementing this in circuit DSLs would take months and be nearly impossible to audit. zkVMs solve this by supporting standard programming languages (Rust, Go, C++) and automatically compiling them to provable instruction sets.

SP1: A RISC-V zkVM

At Zolvency, we use SP1 by Succinct Labs, a zkVM that executes RISC-V bytecode and generates STARK proofs using the PLONKY3 proving system. The workflow is: (1) Write credit scoring logic in Rust, (2) Compile to RISC-V using `cargo prove build`, (3) Execute the program with private inputs (financial data), (4) Generate a STARK proof that the execution was correct, (5) Verify the proof on-chain or off-chain. The beauty is that the verifier only sees the program hash (commitment to the algorithm) and public outputs (the tier: Gold/Silver/Bronze)—never the input data.

// src/main.rs - Runs inside SP1 zkVM
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct Invoice {
    value: f64,
    date: String,
}

#[derive(Serialize)]
struct CreditTier {
    tier: u8, // 1=Bronze, 2=Silver, 3=Gold
}

fn main() {
    // Read private inputs (from zkTLS proof)
    let invoices: Vec<Invoice> = sp1_zkvm::io::read();
    
    // Calculate total monthly revenue (private)
    let total_revenue: f64 = invoices.iter()
        .map(|inv| inv.value)
        .sum();
    
    // Apply risk model (proprietary algorithm)
    let tier = calculate_tier(total_revenue, invoices.len());
    
    // Commit public output only
    sp1_zkvm::io::commit(&CreditTier { tier });
}

fn calculate_tier(revenue: f64, count: usize) -> u8 {
    if revenue >= 100_000.0 && count >= 10 {
        3 // Gold
    } else if revenue >= 50_000.0 && count >= 5 {
        2 // Silver
    } else {
        1 // Bronze
    }
}

Proof Generation and Verification

To generate a proof, we run `sp1_prover::prove()` with the compiled ELF binary and input data. This produces a STARK proof (~500 KB) that can be compressed to a Groth16 proof (~1 KB) for cheaper on-chain verification. The verifier checks: (1) The program hash matches the deployed model, (2) The execution trace is valid (no arithmetic errors, memory violations), (3) The committed output matches the claimed tier. Crucially, the prover cannot fake a 'Gold' tier without actually having the required revenue—this would require forging the STARK proof, which is computationally infeasible.

Performance Characteristics

Proving time scales with program complexity. Our credit scoring algorithm (parsing ~100 invoices, calculating 15 risk factors) takes approximately 2-3 minutes to prove on a modern CPU (8 cores, 16 GB RAM). This is acceptable for a quarterly verification workflow. Verification is fast: ~50ms off-chain, ~200k gas on-chain. Future optimizations include: (1) Recursive proofs (prove multiple months in parallel, aggregate), (2) Hardware acceleration (FPGAs for finite field arithmetic), (3) Precompiles for common operations (SHA-256, JSON parsing).

Security Model

The zkVM's security relies on the soundness of the underlying STARK protocol. Under the assumption that polynomial commitment schemes (FRI protocol in our case) are secure, no adversary can produce a valid proof for an incorrect execution. The privacy guarantee is that the proof reveals nothing about the execution trace (register values, memory access patterns) beyond the public outputs and program hash. This means competitors cannot reverse-engineer the risk model by observing proofs.

Conclusion

zkVMs democratize zero-knowledge computation by eliminating the need for circuit programming expertise. At Zolvency, SP1 enables us to iterate on credit scoring models in hours (not weeks), audit logic using standard Rust tooling, and maintain privacy guarantees without manually crafting arithmetic constraints. As zkVM technology matures with hardware acceleration and recursive aggregation, we anticipate proving times dropping to seconds, unlocking real-time credit decisioning.

zkVM: Running Credit Scoring Algorithms with Zero-Knowledge Proofs