Sistema di Prove a Conoscenza Zero

savitri-zkp fornisce un framework multi-backend per prove a conoscenza zero (ZKP) per la verifica dell'integrità dei blocchi e gli impegni monolith.

Backend

Backend	Flag Funzionalità	Libreria	Caso d'uso
Mock	mock	Nessuna	Sviluppo e test
PLONK	plonk	halo2_proofs	ZKP di uso generale
Arkworks	arkworks	ark-bn254, Groth16	Produzione (curva BN254)

Predefinito: nessun backend abilitato. Il backend mock viene utilizzato per lo sviluppo.

Sicurezza: Il sistema va in panico se viene richiesto un backend di produzione senza il flag di funzionalità corrispondente. Non torna mai silenziosamente al MockVerifier.

Configurazione

pub struct ZkpConfig {
    pub backend: ZkpBackend,
    pub max_proof_size: usize,          // byte
    pub verification_timeout_ms: u64,
}

// Preset
ZkpConfig::development()  // Mock, 1MB, 5s
ZkpConfig::testing()      // Mock, 512KB, 1s
ZkpConfig::production()   // Arkworks, 4MB, 15s

Tipi Fondamentali

Statement

Uno statement contiene gli input pubblici per una prova:

pub struct Statement {
    pub a: [u8; 32],   // campo impegno
    pub b: [u8; 32],   // campo impegno
    pub c: [u8; 32],   // campo impegno
    pub d: [u8; 32],   // campo impegno
    pub e: u64,         // campo scalare
    pub f: u64,         // campo scalare
}

ZkProof

pub struct ZkProof {
    pub proof: Vec<u8>,
    pub public_inputs: Vec<u8>,
    pub verification_key: Vec<u8>,
}

API del Verificatore

pub trait ZkVerifier: Send + Sync {
    fn verify(&self, statement: &Statement, proof: &ZkProof) -> Result<bool>;
    fn batch_verify(&self, statements: &[Statement], proofs: &[ZkProof]) -> Result<Vec<bool>>;
}

Creazione di un Verificatore

use savitri_zkp::{create_verifier, ZkpConfig, ZkpBackend};

// Sviluppo
let verifier = create_verifier(ZkpConfig::development())?;

// Produzione (richiede la funzionalità `arkworks`)
let verifier = create_verifier(ZkpConfig::production())?;

// Verifica una prova
let is_valid = verifier.verify(&statement, &proof)?;

// Verifica batch
let results = verifier.batch_verify(&statements, &proofs)?;

API del Prover

pub trait ZkProver: Send + Sync {
    fn prove(&self, statement: &Statement) -> Result<ZkProof>;
}

Prover Arkworks

// Configurazione trusted setup (genera chiavi di prova + verifica)
let prover = ArkworksProver::from_setup()?;

// Da chiavi esistenti
let prover = ArkworksProver::from_keys(pk_bytes, vk_bytes)?;

// Genera la prova
let proof = prover.prove(&statement)?;

Il prover Arkworks utilizza un seed deterministico (SHA-256("savitri-monolith-sum-circuit-setup-v1")) per un trusted setup riproducibile.

Integrazione Monolith

Le ZKP vengono utilizzate per verificare gli impegni dei blocchi monolith:

Intestazione Monolith

pub struct MonolithHeader {
    pub headers_commit: [u8; 64],   // albero binario SHA-512 delle intestazioni di blocco
    pub state_commit: [u8; 64],     // impegno dello snapshot di stato
    pub exec_height: u64,           // altezza di esecuzione
    pub epoch_id: u64,              // identificatore dell'epoch
}

Impegno sulle Intestazioni

Le intestazioni dei blocchi vengono impegnate tramite riduzione ad albero binario:

leaf_0 = H(block_header_0)
leaf_1 = H(block_header_1)
...
node_01 = SHA-512(leaf_0 || leaf_1)
node_23 = SHA-512(leaf_2 || leaf_3)
...
root = SHA-512(node_01..n-1 || node_23..n)

Impegno Monolith

L'impegno completo lega tutti i campi del monolith:

commitment = SHA-256(
    headers_commit || state_commit || exec_height || epoch_id || prev_state_root
)

Verifica

use savitri_zkp::monolith::monolith_zkp;

// Verifica una prova monolith
let is_valid = monolith_zkp::verify_monolith_proof(
    &verifier,
    &monolith_header,
    &proof,
    prev_epoch_id,
)?;

// Genera una prova monolith
let proof = monolith_zkp::generate_monolith_proof(
    &prover,
    &monolith_header,
)?;

Flag di Funzionalità

[features]
default = []
mock = []                    # MockVerifier (sempre valido)
plonk = ["halo2_proofs"]     # Backend PLONK
arkworks = ["ark-bn254", "ark-groth16", "ark-snark", "ark-relations", "ark-serialize", "ark-std"]
circom = []                  # Riservato per il futuro supporto Circom
production = ["arkworks"]    # Alias produzione
advanced = ["plonk", "arkworks"]
all_backends = ["mock", "plonk", "arkworks"]

Dipendenze

Dipendenza	Backend	Versione
ark-bn254	Arkworks	Ultima
ark-groth16	Arkworks	Ultima
halo2_proofs	PLONK	Ultima
sha2, sha3, blake3	Tutti	Hashing core
bincode	Tutti	Serializzazione

Nessuna Dipendenza da savitri-core

savitri-zkp ha zero dipendenze interne da Savitri per evitare catene di dipendenze circolari. Comunica con le altre crate tramite i tipi Statement e ZkProof.