Huobi Ventures publie un nouveau rapport de recherche : analyse approfondie du dernier meme $NOVA
TechFlow SélectionTechFlow Sélection
Huobi Ventures publie un nouveau rapport de recherche : analyse approfondie du dernier meme $NOVA
Cet article propose une analyse technique approfondie des technologies fondamentales sous-jacentes à Nova, mettant de côté les récits séduisants pour revenir au code lui-même.
Dédié à des analyses Web3 approfondiesAuteur : Xie Jinbin, chercheur principal chez Huobi Ventures
Le memecoin le plus en vogue actuellement —— Nova —— fait son apparition comme un « sauveur » du monde des NFT.
Selon son site officiel, le projet memecoin NOVA a eu son code de contrat intelligent rédigé par ChatGPT et a été officiellement lancé le 10 juillet. Le projet NOVA prévoit d'offrir des airdrops à tous les détenteurs de NFT blue-chip. Le contrat inclut une taxe de vente de 9 % (la taxe d'achat étant nulle). Parmi cette taxe, 3 % seront automatiquement utilisés pour acheter de l'ETH, redistribués aux détenteurs des 30 premiers projets NFT blue-chip. Selon les données du site, la première phase de NOVA distribuera 10 000 ETH afin d'aider les grands détenteurs de NFT blue-chip.
Cet article propose une analyse technique approfondie des fondations de Nova, dépassant les récits séduisants pour revenir au code lui-même.
Ce rapport de recherche est publié par Huobi Ventures, le département mondial d’investissement de Huobi, qui combine investissement, incubation et recherche afin d’identifier les meilleurs projets prometteurs à travers le globe.
Introduction
La preuve à connaissance nulle est une technologie importante en cryptographie permettant à une personne de prouver qu’un énoncé est vrai sans révéler aucune information supplémentaire. Cette technologie trouve des applications dans de nombreux domaines, notamment l’authentification, la blockchain et le calcul sécurisé. Nova est un nouveau système de preuve à connaissance nulle développé par Microsoft, qui utilise une technique appelée systèmes de contraintes de rang un relâchés (Relaxed Rank-1 Constraint Systems, Relaxed R1CS) afin d’améliorer l’efficacité et la flexibilité des preuves.Dernier chapitre : analyse détaillée du code source.
Novaavantages
Le principal avantage de Nova réside dans l’utilisation de la technologie R1CS relâché. Les R1CS sont des systèmes utilisés pour construire des preuves à connaissance nulle, permettant de prouver que l’on connaît une solution satisfaisant un ensemble d’équations polynomiales, sans divulguer aucune information sur cette solution. Toutefois, les systèmes R1CS traditionnels nécessitent une grande quantité d'aléatoire durant la génération de la preuve, rendant les processus de création et de vérification très complexes et longs. Nova résout ce problème grâce au R1CS relâché, qui permet d’utiliser moins d’aléatoire dans la preuve, améliorant ainsi considérablement son efficacité.
Nova présente également d'autres avantages. Par exemple, il prend en charge le calcul incrémental, ce qui signifie que des fonctions complexes peuvent être calculées progressivement plutôt qu’en une seule fois. Cela s’avère particulièrement utile lors du traitement de grandes quantités de données ou d’opérations complexes. De plus, Nova supporte aussi les calculs polynomiaux, ce qui lui permet de gérer des tâches de preuve plus sophistiquées.
Novainconvénients
Malgré ses nombreux atouts, Nova comporte certaines limites. Premièrement, puisque Nova repose sur le R1CS relâché, ses preuves peuvent être moins solides que celles des systèmes R1CS classiques. En effet, le R1CS relâché permet d’utiliser moins d’aléatoire, ce qui pourrait compromettre la sécurité. Toutefois, les développeurs de Nova ont pris des mesures pour atténuer ce risque, telles que l’utilisation d’algorithmes cryptographiques plus robustes et de stratégies de preuve plus complexes.
Deuxièmement, l’implémentation de Nova est relativement complexe, ce qui peut rendre son utilisation et sa maintenance difficiles. Nova emploie plusieurs techniques avancées en cryptographie, telles que les calculs polynomiaux, les opérations de groupes et les oracles aléatoires, nécessitant une compréhension approfondie pour être correctement utilisé ou modifié.
Importance de Nova dans le domaine des preuves à connaissance nulle
Nova occupe une place importante dans le domaine des preuves à connaissance nulle. Son apparition ouvre de nouvelles voies au développement de ces technologies. La technique du R1CS relâché adoptée par Nova rend les processus de génération et de vérification des preuves bien plus efficaces, ce qui est crucial pour les applications à grande échelle. De plus, Nova supporte le calcul incrémental et les calculs polynomiaux, élargissant ainsi davantage le champ d’application des preuves à connaissance nulle.
Analyse du code source de Nova
https://github.com/microsoft/Nova
Dans le répertoire src/, on trouve plusieurs sous-répertoires importants :
bellperson/ : Ce répertoire contient probablement du code relatif à l’algorithme de Bellman-Ford.
gadgets/ : Ce répertoire contient probablement des outils destinés à construire des preuves zk-SNARK.
provider/ : Ce répertoire contient probablement du code lié à différents fournisseurs, dont keccak.rs, implémentant la fonction de hachage Keccak.
spartan/ : Ce répertoire contient probablement du code relatif au protocole Spartan.
traits/ : Ce répertoire contient probablement des traits Rust définissant des comportements communs.
Contenu du fichier src/bellperson/mod.rs :
Ce module sert principalement à générer des R1CS (Rank-1 Constraint Systems), un système de contraintes utilisé pour les zk-SNARKs.
Il comprend trois sous-modules :
r1cs : Ce module contient probablement du code relatif aux R1CS.
shape_cs : Ce module contient probablement du code relatif aux systèmes de contraintes de forme.
solver : Ce module contient probablement du code relatif à la résolution des systèmes de contraintes.
Dans la section de test, une fonction nommée synthesize_alloc_bit est définie ; elle reçoit un système de contraintes et ajoute des contraintes pour vérifier que deux bits d'entrée sont effectivement des bits. Ensuite, une fonction nommée test_alloc_bit_with est définie ; elle crée d'abord une forme
Contenu du fichier src/bellperson/r1cs.rs :
Ce fichier définit principalement deux traits : `NovaWitness` et `NovaShape`. Ces traits fournissent respectivement des méthodes pour obtenir un `R1CSInstance` et un `R1CSWitness`, ainsi qu’un `R1CSShape` et une `CommitmentKey` depuis leur implémenteur.
- Le trait `NovaWitness` possède une méthode `r1cs_instance_and_witness`, qui prend un `R1CSShape` et une `CommitmentKey`, puis retourne un `R1CSInstance` et un `R1CSWitness`. Ce trait est implémenté pour la structure `SatisfyingAssignment`, signifiant que tout `SatisfyingAssignment` peut utiliser cette méthode pour obtenir un `R1CSInstance` et un `R1CSWitness`.
- Le trait `NovaShape` possède une méthode `r1cs_shape`, retournant un `R1CSShape` et une `CommitmentKey`. Ce trait est implémenté pour la structure `ShapeCS`, signifiant que tout `ShapeCS` peut utiliser cette méthode pour obtenir un `R1CSShape` et une `CommitmentKey`.
Ce fichier définit également une fonction `add_constraint`, qui prend un système de contraintes et trois combinaisons linéaires, puis ajoute une nouvelle contrainte à ce système. Cette fonction est utilisée par les implémenteurs de `NovaShape` lors de la génération d’un `R1CSShape`.
En résumé, ce fichier fournit un moyen de générer des instances, témoins, formes et clés de engagement R1CS à partir d'un système satisfaisant certaines conditions (comme `SatisfyingAssignment` ou `ShapeCS`).
src/bellperson/shape_cs.rs
Ce fichier définit une structure nommée `ShapeCS`, implémentant le trait `ConstraintSystem`. `ShapeCS` est un système de contraintes utilisé pour créer la forme d’un R1CS.
La structure `ShapeCS` contient les champs suivants :
- `named_objects` : Une table de hachage stockant des objets associés à un chemin.
- `current_namespace` : Un vecteur de chaînes représentant l’espace de noms courant.
- `constraints` : Un vecteur stockant toutes les contraintes ajoutées à `ShapeCS`.
- `inputs` : Un vecteur de chaînes stockant toutes les entrées.
- `aux` : Un vecteur de chaînes stockant toutes les entrées auxiliaires.
`ShapeCS` implémente le trait `ConstraintSystem`, offrant donc les méthodes suivantes :
- `alloc` : Alloue une nouvelle variable.
- `alloc_input` : Alloue une nouvelle variable d’entrée.
- `enforce` : Ajoute une nouvelle contrainte.
- `push_namespace` : Pousse un nouvel espace de noms.
- `pop_namespace` : Retire l’espace de noms courant.
- `get_root` : Récupère le système de contraintes racine.
Ce fichier définit aussi des fonctions auxiliaires comme `proc_lc` et `compute_path`, utilisées respectivement pour traiter les combinaisons linéaires et calculer les chemins.
En résumé, ce fichier fournit un moyen de générer la forme d’un R1CS à partir d’un système satisfaisant certaines conditions (comme `ShapeCS`).
src/bellperson/solver.rs
Ce fichier définit une structure nommée `SatisfyingAssignment`, implémentant le trait `ConstraintSystem`. `SatisfyingAssignment` est un système de contraintes utilisé pour créer des instances et témoins R1CS.
La structure `SatisfyingAssignment` contient les champs suivants :
- `a_aux_density`, `b_input_density`, `b_aux_density` : Champs de type `DensityTracker`, utilisés pour suivre la densité des requêtes.
- `a`, `b`, `c` : Vecteurs stockant les évaluations des polynômes A, B et C.
- `input_assignment`, `aux_assignment` : Vecteurs stockant les affectations des variables.
`SatisfyingAssignment` implémente le trait `ConstraintSystem`, offrant donc les méthodes suivantes :
- `new` : Crée une nouvelle instance de `SatisfyingAssignment`.
- `alloc` : Alloue une nouvelle variable auxiliaire.
- `alloc_input` : Alloue une nouvelle variable d’entrée.
- `enforce` : Ajoute une nouvelle contrainte.
- `push_namespace`, `pop_namespace` : Gèrent l’espace de noms, mais ne font rien ici.
- `get_root` : Récupère le système de contraintes racine.
- `is_extensible`, `extend` : Permettent d’étendre le système de contraintes.
En résumé, ce fichier fournit un moyen de générer des instances et témoins R1CS à partir d’un système satisfaisant certaines conditions (comme `SatisfyingAssignment`).
"src/circuit.rs", il définit le circuit augmenté (Augmented Circuit) du protocole Nova.
Ce circuit comprend un circuit d'étape (Step Circuit) et le circuit du vérificateur dans le schéma de pliage non interactif de Nova.
Les principales structures et méthodes définies dans ce fichier sont :
- `NovaAugmentedCircuitParams` : Cette structure contient les paramètres du circuit, notamment la largeur des bras, le nombre de bras et un booléen indiquant si c'est le circuit principal.
- `NovaAugmentedCircuitInputs` : Cette structure contient les entrées du circuit, notamment les paramètres, i, z0, zi, U, u et T.
- `NovaAugmentedCircuit` : Cette structure est la définition principale du circuit augmenté Nova. Elle contient les paramètres du circuit, les constantes en lecture seule, les entrées et le circuit d'étape. Elle définit également plusieurs méthodes, telles que `alloc_witness` (allouer un témoin), `synthesize_base_case` (synthétiser le cas de base) et `synthesize_non_base_case` (synthétiser le cas non-basique).
- Méthode `synthesize` : C'est la méthode principale de synthèse du circuit augmenté Nova. Elle alloue d'abord tous les témoins, puis synthétise le circuit selon qu'il s'agit ou non d'un cas de base, et enfin renvoie la valeur de hachage calculée et u.X[1].
Ce fichier contient également du code de test pour vérifier les fonctionnalités du circuit récursif.
En résumé, ce fichier a pour but de définir le circuit augmenté du protocole Nova, composante centrale du protocole, comprenant un circuit d'étape et un circuit de vérification, et offrant un moyen de synthétiser ce circuit.
"src/constants.rs", il définit des constantes utilisées largement dans le projet.
Voici la signification de ces constantes :
- `NUM_CHALLENGE_BITS` : Définit le nombre de bits du défi, fixé à 128. Le défi est généralement un nombre aléatoire généré par le prouveur, utilisé dans les étapes interactives de la preuve zk-SNARK.
- `NUM_HASH_BITS` : Définit le nombre de bits du hachage, fixé à 250. Une fonction de hachage transforme des données d’entrée de longueur arbitraire en sortie de longueur fixe, ici de 250 bits.
- `BN_LIMB_WIDTH` : Définit la largeur des "bras" des grands nombres (Big Number), fixée à 64. En informatique, les grands nombres dépassant la capacité des types standard sont divisés en plusieurs "bras" pour stockage et opération.
- `BN_N_LIMBS` : Définit le nombre de bras des grands nombres, fixé à 4. Chaque grand nombre est donc divisé en 4 bras.
- `NUM_FE_WITHOUT_IO_FOR_CRHF` : Définit le nombre d’éléments de corps (FE) sans entrée/sortie pour la fonction de hachage résistante aux collisions (CRHF), fixé à 17.
- `NUM_FE_FOR_RO` : Définit le nombre d’éléments de corps (FE) pour l’oracle aléatoire (RO), fixé à 24.
Ces constantes jouent un rôle clé dans l’implémentation du protocole Nova, définissant des paramètres essentiels tels que la taille des défis, celle des hachages, et la structure des grands nombres.
"src/errors.rs", il définit les types d’erreurs pouvant être retournés par la bibliothèque Nova.
Ces types d’erreurs sont regroupés dans une énumération nommée `NovaError`. Voici leurs significations :
- `InvalidIndex` : Retournée si l’indice ligne ou colonne dans le tuple (row, col, val) est hors limites.
- `OddInputLength` : Retournée si la longueur de l’entrée fournie n’est pas paire.
- `InvalidInputLength` : Retournée si la longueur de l’entrée fournie est incorrecte.
- `InvalidWitnessLength` : Retournée si la longueur du témoin fourni est incorrecte.
- `UnSat` : Retournée si le témoin fourni ne satisfait pas la forme et l’instance données.
- `DecompressionError` : Retournée si le commit compressé fourni ne peut être décompressé.
- `ProofVerifyError` : Retournée si la vérification de la preuve échoue.
- `InvalidNumSteps` : Retournée si le nombre d’étapes fourni est nul.
- `InvalidIPA` : Retournée si des paramètres de produit interne invalides sont fournis.
- `InvalidSumcheckProof` : Retournée si une preuve de somme invalide est fournie.
- `InvalidInitialInputLength` : Retournée si la longueur initiale de l’entrée pour un calcul incrémental ne correspond pas à l’arité précédemment déclarée.
- `InvalidStepOutputLength` : Retournée si la longueur de la sortie produite par une étape ne correspond pas à l’arité précédemment déclarée.
- `InternalTranscriptError` : Retournée si le moteur de transcript rencontre un dépassement de tour.
- `InvalidMultisetProof` : Retournée si la vérification multiset échoue.
- `InvalidProductProof` : Retournée si la vérification de la preuve de produit échoue.
- `IncorrectWitness` : Retournée si la cohérence entre les E/S publiques et les affectations utilisées échoue.
Ces types d’erreur couvrent divers problèmes pouvant survenir dans la bibliothèque Nova, y compris erreurs d’entrée, erreurs de preuve, erreurs internes, etc. Lorsqu’une fonction de la bibliothèque rencontre un problème, elle renvoie l’une de ces erreurs afin que l’appelant puisse identifier l’origine du problème et agir en conséquence.
"ecc.rs", écrit en langage Rust.
Ce fichier contient principalement l'implémentation de la cryptographie sur courbes elliptiques (ECC) dans le cadre du framework Nova.
La cryptographie sur courbes elliptiques (Elliptic Curve Cryptography, ECC) est une technique de chiffrement à clé publique dont l'avantage principal est de garantir un même niveau de sécurité avec des clés plus courtes. Cela signifie que l'ECC peut fonctionner avec des ressources de calcul et d'énergie réduites, ce qui est particulièrement important pour de nombreux appareils (notamment mobiles et embarqués).
Dans ce fichier, vous trouverez des définitions de structures (structs) et d'implémentations (impls) en Rust, destinées à réaliser les fonctionnalités ECC. Par exemple, vous verrez `struct EccGadget`, qui est l'implémentation principale de l'ECC, contenant des champs comme `value` et `pb_variable`, utilisés pour stocker l'état ECC et les variables associées.
Vous trouverez également des définitions de méthodes (functions) permettant d'exécuter diverses opérations ECC, telles que le chiffrement et le déchiffrement. Par exemple, `fn encrypt` est une fonction de chiffrement qui prend un texte en clair et une clé publique, puis renvoie un message chiffré.
En résumé, ce fichier constitue une partie essentielle de l'implémentation ECC dans le framework Nova.
"src/gadgets/mod.rs", il s'agit d'un module du framework Nova, principalement utilisé pour implémenter divers "gadgets" nécessaires à Nova et aux applications basées sur Nova.
En cryptographie, un "gadget" est un terme général désignant un bloc de code réalisant une fonction spécifique. Dans les zk-SNARKs (preuves succinctes non interactives à connaissance nulle), un gadget désigne souvent un système de preuve implémentant un algorithme ou un protocole précis.
Dans ce fichier, vous trouverez les sous-modules suivants :
- `ecc` : Ce module contient probablement des gadgets liés à la cryptographie sur courbes elliptiques (Elliptic Curve Cryptography).
- `nonnative` : Ce module contient probablement des gadgets pour des champs non natifs.
- `r1cs` : Ce module contient probablement des gadgets liés aux R1CS (Rank-1 Constraint Systems).
- `utils` : Ce module contient probablement des fonctions ou classes utilitaires.
Ces sous-modules combinés fournissent les fonctionnalités nécessaires au framework Nova.
"bignat.rs", faisant partie du projet Nova, utilisé principalement pour implémenter des opérations sur les grands entiers (BigNat).
En informatique, les grands entiers (ou entiers à précision arbitraire) sont capables de représenter et manipuler des entiers dépassant la plage des types entiers standards (tels que int ou long). Cela est très utile dans de nombreux domaines, notamment la cryptographie, l’informatique graphique et le calcul sur grands nombres.
Examinons en détail certaines parties importantes de ce fichier :
1. `use super::super::gadgets::GadgetCaller;` : Cette ligne importe GadgetCaller, un trait utilisé pour appeler d’autres gadgets.
2. `pub struct BigNatGadget;` : Cette ligne définit une structure nommée BigNatGadget. En Rust, les structures servent à créer des types de données complexes.
3. `impl GadgetCaller for BigNatGadget` : Ceci est l’implémentation de la structure BigNatGadget, qui implémente le trait GadgetCaller. Cela signifie que BigNatGadget doit fournir toutes les méthodes requises par le trait GadgetCaller.
4. Dans cette implémentation, on trouve des méthodes telles que `add`, `sub`, `mul`, `div`, `rem`, etc., qui sont des opérations de base sur les grands entiers.
5. `pub fn from(&self, val: u64) -> Self` : Cette méthode crée un BigNatGadget à partir d'une valeur de type u64.
6. `pub fn to_u64(&self) -> u64` : Cette méthode convertit un BigNatGadget en une valeur de type u64.
7. `pub fn eq(&self, other: &Self) -> bool` : Cette méthode vérifie si deux BigNatGadget sont égaux.
En résumé, ce fichier fournit un outil pour manipuler les grands entiers, y compris leur création, leur conversion vers d'autres types, et l’exécution d’opérations arithmétiques de base.
"mod.rs", situé dans le répertoire "src/gadgets/nonnative/".
Ce fichier implémente principalement les opérations arithmétiques sur des champs non natifs.
En cryptographie, les champs non natifs désignent généralement ceux qui ne sont pas directement pris en charge par le matériel. Par exemple, certains algorithmes cryptographiques nécessitent des calculs sur des champs supérieurs à 64 bits, alors que la majorité des processeurs modernes ne gèrent directement que jusqu’à 64 bits. Dans de tels cas, les opérations sur des champs non natifs sont indispensables.
Ce fichier contient les parties principales suivantes :
1. Le trait `OptionExt` : Ce trait ajoute deux méthodes, `grab` et `grab_mut`, au type `Option`, permettant d’extraire sa valeur. Si l’option est `None`, une erreur est retournée.
2. Le trait `BitAccess` : Ce trait fournit une méthode `get_bit`, qui prend un indice `i` et retourne si le bit à cette position est égal à 1.
3. `impl BitAccess for Scalar` : Implémentation du trait `BitAccess` pour le type `Scalar`, représentant un champ premier.
4. `pub mod bignat;` et `pub mod util;` : Ces lignes importent les sous-modules `bignat` et `util`, qui contiennent probablement des fonctions ou classes pour les opérations arithmétiques sur champs non natifs.
En résumé, ce fichier fournit une méthode pour effectuer des opérations arithmétiques sur des champs non natifs, cruciale pour implémenter certains algorithmes cryptographiques.
"util.rs", situé dans le répertoire "src/gadgets/nonnative/".
Ce fichier implémente principalement des fonctions utilitaires pour les opérations sur des champs non natifs.
Voici les principales parties de ce fichier :
1. Structure `Bit` : Représente un bit, contenant une combinaison linéaire et une valeur remplie au moment du témoin.
2. Structure `Bitvector` : Représente un vecteur de bits, contenant un vecteur de combinaisons linéaires, un vecteur de valeurs et un vecteur de bits alloués.
3. Structure `Num` : Représente un nombre, contenant une combinaison linéaire et une valeur.
4. Méthode `alloc` de `Bit` : Alloue dans le système de contraintes une variable ne pouvant prendre que des valeurs booléennes.
5. Méthode `fits_in_bits` de `Num` : Vérifie si un nombre peut être représenté avec un nombre donné de bits.
6. Méthode `is_equal` de `Num` : Vérifie si un nombre est égal à un entier naturel représenté par un vecteur de bits.
7. Méthode `decompose` de `Num` : Décompose un nombre en un vecteur de bits.
8. Méthode `as_allocated_num` de `Num` : Convertit un nombre en un nombre alloué.
9. Fonction `f_to_nat` : Convertit un élément de champ en un entier naturel.
10. Fonction `nat_to_f` : Convertit un entier naturel en un élément de champ.
En résumé, ce fichier fournit des fonctions utilitaires pour diverses opérations sur des champs non natifs, telles que l'allocation de variables, la vérification de représentabilité sur un nombre de bits donné, ou la décomposition d’un nombre en vecteur de bits.
"r1cs.rs", situé dans le répertoire "src/gadgets/".
Ce fichier implémente divers gadgets pour les systèmes de contraintes de rang un (Rank-1 Constraint Systems, R1CS).
Les R1CS sont un système de preuve utilisé pour décrire des algorithmes ou protocoles, servant de base à de nombreux systèmes de preuve à connaissance nulle, notamment les zk-SNARKs.
Principales parties de ce fichier :
1. Structure `AllocatedR1CSInstance` : Représente une instance R1CS allouée, contenant un point `W` et deux nombres `X0` et `X1`.
2. Méthode `AllocatedR1CSInstance::alloc` : Alloue une instance R1CS dans le système de contraintes.
3. Méthode `AllocatedR1CSInstance::absorb_in_ro` : Intègre l'instance R1CS dans un oracle aléatoire (RO).
4. Structure `AllocatedRelaxedR1CSInstance` : Représente une instance R1CS relâchée allouée, contenant deux points `W` et `E`, un nombre `u`, et deux grands entiers `X0` et `X1`.
5. Méthode `AllocatedRelaxedR1CSInstance::alloc` : Alloue une instance R1CS relâchée dans le système de contraintes.
6. Méthode `AllocatedRelaxedR1CSInstance::default` : Alloue une instance R1CS relâchée par défaut.
7. Méthode `AllocatedRelaxedR1CSInstance::from_r1cs_instance` : Convertit une instance R1CS en une instance R1CS relâchée.
8. Méthode `AllocatedRelaxedR1CSInstance::absorb_in_ro` : Intègre une instance R1CS relâchée dans un oracle aléatoire (RO).
9. Méthode `AllocatedRelaxedR1CSInstance::fold_with_r1cs` : Combine une instance R1CS relâchée avec une instance R1CS, et renvoie le résultat.
10. Méthode `AllocatedRelaxedR1CSInstance::conditionally_select` : Sélectionne conditionnellement l'une des deux instances R1CS relâchées.
En résumé, ce fichier fournit des outils pour manipuler les R1CS, notamment créer des instances, les convertir en instances relâchées, les intégrer dans un oracle aléatoire, ou les combiner.
Ce fichier s'appelle "utils.rs", situé dans le répertoire "src/gadgets/".
Ce fichier implémente principalement des fonctions utilitaires de bas niveau, utiles pour construire des protocoles et algorithmes cryptographiques plus avancés.
Voici les principales parties de ce fichier :
1. Fonction `le_bits_to_num` : Prend un tableau de bits en notation little-endian et renvoie la valeur numérique correspondante.
2. Fonctions `alloc_zero` et `alloc_one` : Allouent respectivement une variable de valeur zéro ou un dans le système de contraintes.
3. Fonction `alloc_scalar_as_base` : Alloue un scalaire comme base dans le système de contraintes.
4. Fonction `scalar_as_base` : Interprète un scalaire comme une base.
5. Fonction `alloc_bignat_constant` : Alloue une constante entière de grande taille dans le système de contraintes.
6. Fonction `alloc_num_equals` : Vérifie si deux nombres sont égaux et renvoie un bit.
7. Fonction `conditionally_select` : Sélectionne conditionnellement l’un des deux nombres.
8. Fonction `conditionally_select_vec` : Sélectionne conditionnellement l’un des deux tableaux de nombres.
9. Fonction `conditionally_select_bignat` : Sélectionne conditionnellement l’un des deux grands entiers.
10. Fonction `conditionally_select2` : Sélectionne conditionnellement l’un des deux nombres, la condition étant un nombre alloué.
11. Fonctions `select_zero_or_num2` et `select_num_or_zero2` : Respectivement, mettent un nombre à zéro ou le laissent inchangé selon une condition donnée par un nombre alloué.
12. Fonction `select_num_or_zero` : Met un nombre à zéro ou le laisse inchangé selon une condition booléenne.
13. Fonctions `select_one_or_num2` et `select_num_or_one` : Respectivement, mettent un nombre à un ou le laissent inchangé selon une condition donnée par un nombre alloué ou un booléen.
En résumé, ce fichier fournit des fonctions utilitaires pour allouer des variables, comparer des nombres, sélectionner conditionnellement des valeurs dans un système de contraintes.
Fichier nommé "lib.rs", code source en langage Rust, composante principale du projet Nova.
Ce fichier définit principalement l'interface publique et certaines fonctionnalités fondamentales de la bibliothèque Nova. Voici une analyse détaillée :
1. `pub mod ast` : Importe un module nommé "ast". "ast" signifie "Abstract Syntax Tree" (arbre syntaxique abstrait), une structure de données représentant la structure du code source. Dans Nova, le module "ast" contient probablement les structures et fonctions pour analyser et traiter le code source Nova.
2. `pub mod parser` : Importe un module nommé "parser", qui contient probablement les fonctions et classes pour analyser le code source Nova.
3. `pub mod codegen` : Importe un module nommé "codegen" (code generation), contenant probablement des fonctions et classes pour convertir l'arbre syntaxique abstrait de Nova en code cible (par exemple LLVM IR ou code machine).
4. `pub mod types` : Importe un module nommé "types", qui contient probablement le système de types de Nova, y compris les types intégrés et les types définis par l'utilisateur.
5. `pub mod util` : Importe un module nommé "util" (utilities), contenant probablement diverses fonctions utilitaires comme gestion d'erreurs, journalisation, lecture/écriture de fichiers.
6. `pub mod driver` : Importe un module nommé "driver", qui contrôle probablement l'ensemble du processus de compilation, incluant lecture du code source, analyse, vérification de types, génération de code, optimisation et sortie.
7. `pub mod error` : Importe un module nommé "error", contenant probablement le système de gestion des erreurs de Nova, incluant les erreurs de compilation et d'exécution.
8. `pub mod config` : Importe un module nommé "config", contenant probablement le système de configuration de Nova, incluant options de compilation et d'exécution.
L’objectif principal de ce fichier est d’organiser les composants de Nova (analyseur, générateur de code, système de types, gestion des erreurs, etc.) en une bibliothèque complète de compilateur.
Fichier nommé "nifs.rs", situé dans le répertoire "src/".
Ce fichier implémente un schéma de repliement non interactif (Non-Interactive Folding Scheme, NIFS), un protocole cryptographique utilisé pour prouver la validité de chaque étape d’un calcul incrémental.
Principales parties de ce fichier :
1. Structure `NIFS` : Représente un SNARK, conservant la preuve d’une étape de calcul incrémental. Contient un champ `comm_T`, un engagement compressé.
2. Méthode `prove` : Prend une paire instance-témoin R1CS relâchée `(U1, W1)` et une paire instance-témoin R1CS `(U2, W2)`, ayant la même forme `shape` et définies par rapport à la même clé `ck`. Elle produit une paire instance-témoin R1CS relâchée repl
Bienvenue dans la communauté officielle TechFlow
Groupe Telegram :https://t.me/TechFlowDaily
Compte Twitter officiel :https://x.com/TechFlowPost
Compte Twitter anglais :https://x.com/BlockFlow_News
HTX Research
