Système de preuves à divulgation nulle de connaissance

savitri-zkp fournit un cadre de preuve à divulgation nulle de connaissance multi-backend pour la vérification de l'intégrité des blocs et les engagements de monolithes.

Backends

Backend	Indicateur de fonctionnalité	Bibliothèque	Cas d'usage
Mock	mock	Aucune	Développement et tests
PLONK	plonk	halo2_proofs	ZKP à usage général
Arkworks	arkworks	ark-bn254, Groth16	Production (courbe BN254)

Par défaut : aucun backend activé. Le backend mock est utilisé pour le développement.

Sécurité : Le système panique si un backend de production est demandé sans l'indicateur de fonctionnalité correspondant. Il ne se replie jamais silencieusement sur MockVerifier.

Configuration

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

// Préréglages
ZkpConfig::development()  // Mock, 1 Mo, 5s
ZkpConfig::testing()      // Mock, 512 Ko, 1s
ZkpConfig::production()   // Arkworks, 4 Mo, 15s

Types fondamentaux

Statement (Énoncé)

Un énoncé contient les entrées publiques d'une preuve :

pub struct Statement {
    pub a: [u8; 32],   // champ d'engagement
    pub b: [u8; 32],   // champ d'engagement
    pub c: [u8; 32],   // champ d'engagement
    pub d: [u8; 32],   // champ d'engagement
    pub e: u64,         // champ scalaire
    pub f: u64,         // champ scalaire
}

ZkProof (Preuve ZK)

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

API du vérificateur

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>>;
}

Création d'un vérificateur

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

// Développement
let verifier = create_verifier(ZkpConfig::development())?;

// Production (nécessite la fonctionnalité `arkworks`)
let verifier = create_verifier(ZkpConfig::production())?;

// Vérifier une preuve
let is_valid = verifier.verify(&statement, &proof)?;

// Vérification par lot
let results = verifier.batch_verify(&statements, &proofs)?;

API du prouveur

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

Prouveur Arkworks

// Configuration de confiance (génère les clés de preuve + de vérification)
let prover = ArkworksProver::from_setup()?;

// À partir de clés existantes
let prover = ArkworksProver::from_keys(pk_bytes, vk_bytes)?;

// Générer une preuve
let proof = prover.prove(&statement)?;

Le prouveur Arkworks utilise une graine déterministe (SHA-256("savitri-monolith-sum-circuit-setup-v1")) pour une configuration de confiance reproductible.

Intégration des monolithes

ZKP est utilisé pour vérifier les engagements de blocs monolithes :

En-tête de monolithe

pub struct MonolithHeader {
    pub headers_commit: [u8; 64],   // arbre binaire SHA-512 des en-têtes de blocs
    pub state_commit: [u8; 64],     // engagement d'instantané d'état
    pub exec_height: u64,           // hauteur d'exécution
    pub epoch_id: u64,              // identifiant d'époque
}

Engagement des en-têtes

Les en-têtes de blocs sont engagés via une réduction en arbre binaire :

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)

Engagement du monolithe

L'engagement complet lie tous les champs du monolithe :

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

Vérification

use savitri_zkp::monolith::monolith_zkp;

// Vérifier une preuve de monolithe
let is_valid = monolith_zkp::verify_monolith_proof(
    &verifier,
    &monolith_header,
    &proof,
    prev_epoch_id,
)?;

// Générer une preuve de monolithe
let proof = monolith_zkp::generate_monolith_proof(
    &prover,
    &monolith_header,
)?;

Indicateurs de fonctionnalité

[features]
default = []
mock = []                    # MockVerifier (toujours valide)
plonk = ["halo2_proofs"]     # Backend PLONK
arkworks = ["ark-bn254", "ark-groth16", "ark-snark", "ark-relations", "ark-serialize", "ark-std"]
circom = []                  # Réservé pour le support futur de Circom
production = ["arkworks"]    # Alias de production
advanced = ["plonk", "arkworks"]
all_backends = ["mock", "plonk", "arkworks"]

Dépendances

Dépendance	Backend	Version
ark-bn254	Arkworks	Dernière
ark-groth16	Arkworks	Dernière
halo2_proofs	PLONK	Dernière
sha2, sha3, blake3	Tous	Hachage de base
bincode	Tous	Sérialisation

Absence de dépendance à savitri-core

savitri-zkp ne possède aucune dépendance interne à Savitri afin d'éviter les chaînes de dépendances circulaires. Il communique avec les autres crates via les types Statement et ZkProof.