Cairo est un langage de programmation Turing-complet à usage général permettant d’écrire des programmes prouvables. StarkNet utilise le Langage Cairo pour son infrastructure et l’écriture des smart contracts.
Avec les problèmes de scalabilité liée à Ethereum et son langage de programmation Solidity, un nouveau paradigme s’est formé, nommé “Provable Computation” en français “calcul prouvable”. Solidity a amené le paradigme des “calcul composable” et bien maintenant avec les calculs prouvables, les avantages du calcul composable sont conservés, mais il est également possible aux programmes de prouver qu’ils ont été exécutés sans avoir à être réexécutés.
Un composant off-chain (prouver) prend en charge les exécutions les plus complexes et communique avec un smart contract on-chain (smart contract de vérification) le tout sans renoncer à la sécurité du système, car tous les changements d’état du système sont garantis par des preuves STARK ou Snark.
En quoi la scalabilité est améliorée ?
La vérification d’une preuve on-chain est exponentiellement moins chère que l’ensemble d’une exécution on-chain.
C’est ainsi que de plus en plus d’applications se tournent vers des solutions dites de Layer 2 tels que StarkNet, c’est au sein de ce nouveau paradigme que le langage Cairo intervient !
En effet, Cairo a été conçu dans le but de prouver succinctement l’exécution correcte d’un programme, il est sans état, ce qui signifie que vous n’avez pas d’accès natif au stockage, ni aux autres programmes Cairo, ni à l’état L1.
Cependant, dans la machine virtuelle StarkNet Virtuelle, il y a un état persistant auquel les smart contracts peuvent accéder et modifier. Les SC peuvent stocker des variables, communiquer avec d’autres contracts, échanger des messages L2<>L1 et inversement.
StarkNet est donc un réseau dont l’exécution est programmée en Cairo, et dont les transitions d’états peuvent être prouvées grâce à des preuves Stark.
Comment s’exécute Cairo ?
L’exécution d’un programme Cairo génère une trace qui est ensuite envoyée à un prouver trustless qui à son tour génère une STARK-proof validant l’énoncé ou le calcul représenté par le programme Cairo. S’ensuit que la preuve peut être vérifiée à l’aide d’un vérifier (pouvant être on-chain ou non)
Autrement dit, le prouver exécute le programme et créer une preuve qui renvoie une sortie Y quand on lui donne une entrée X (à vérifier)
Et en pratique ?
- Écrivez votre programme avec Cairo
- Générez une preuve d’exécution (off-chain)
- Envoyez la preuve au contrat de vérification (on chain)
- Une fois validé (on-chain), votre application peut utiliser le résultat en toute confiance
Toutes fois ceci ne serait possible sans ce fameux prouver !
The Shared Prover – L’élément essentiel au processus
SHARP est un prouver public qui génère les preuves de validité des traces des programmes envoyés par les utilisateurs.
SHARP comprend 3 composants principaux :
→ un prouver (off-chain)
→ un smart contract du vérifieur (on-chain)
→ un contrat de registre de faits (on-chain)
Comment fonctionne SHARP ?
SHARP – Shared Prover, génère actuellement les preuves attestant de la validité des exécutions des programmes issus du langage Cairo comme la transition d’état de StarkNet. Ceci est assuré par OS StarkNet OS.
Fonctionnement :
- le prouver prend la trace d’exécution de votre programme Cairo
- prouve qu’il est valide et envoie cette preuve au vérifieur
- après vérification de la preuve, le vérifier écrit un fait attestant de la validité de la preuve dans le registre des faits on-chain (ce fait un comparable à un sceau d’approbation trustless, certifiant que le programme écrit en Cairo a été calculé correctement)
- le smart contract de la dApp vérifier que ce fait existe permettant de s’appuyer sur le calcul qui a été exécuté off-chain
Pourquoi StarkNet utilise SHARP ?
Le programme Cairo qui assure la validité des transitions d’états de StarkNet est l’OS StarkNet. Étant écrit en Cairo, il peut utiliser SHARP.
Les preuves de transition d’état de StarkNet peuvent être réalisée avec un ensemble de programmes qui ne sont pas liés à StarkNet, ce qui réduit le coût marginal de chaque participant.
L’intérêt pour StarkNet d’utiliser SHARP est d’avoir un prouver dédié garantissant plusieurs paramètres, dont les TPS.
Qu’est-ce que AIRs ?
La fonction principale d’un programme Cairo est de traduire du code lisible pour ainsi générer des STARKs-proof. L’AIR est une étape intermédiaire dans ce processus.
AIR peut-être considéré comme ceci :
→ AIR déconstruit un programme et le reconstruit comme une feuille de calcul
→ chaque ligne et colonne de la feuille de calcul représente différentes parties du programme
→ à chaque progression du programme, de nouvelles lignes sont ajoutées à la feuille de calcul
⇒ le tableur permet une vérification ligne par ligne du programme, ainsi si toutes les vérifications réussissent, le programme passe à l’étape suivante qui est la génération d’une preuve
AIR permet de décomposer le code complexe de Cairo en plus petites parties, permettant ainsi de résoudre n’importe quel problème arbitraire sans avoir besoin de réécrire les vérifications demandées.
Outils – Cairo !
Le Compilateur permet de traduire des programmes Cairo en Cairo bytecode
La Machine Virtuelle Cairo est un logiciel permettant d’utiliser le bytecode produit par le compilateur afin de l’exécuter sur un ordinateur. La sortie de cette exécution est la trace du programme qui peut ensuite être envoyée à un prouver STARK validant ainsi l’énoncé exprimé dans le code Cairo.
Le Tracer permet de déboguer en affichant une représentation visuelle de la trace pendant l’exécution du programme, permettant ainsi au développeur d’identifier les problèmes et d’observer plus en détails l’exécution du code.
Cas d’utilisation
Scalabilité : en supposant que le smart contract de vérification connaisse le hash du programme, le temps de vérification ne dépend pas linéairement de la taille du programme.
Confidentialité : le smart contract de vérification peut vérifier l’exécution d’un programme sans savoir ce que fait le programme.
Une preuve issue de Cairo par analogie est comme un reçu qui convainc un tiers qu’un programme a été exécuter, ceci sans dévoiler les entrées du programme. C’est ainsi qu’une forte confidentialité peut être obtenue avec Cairo, car on peut imager qu’un utilisateur inclue des secrets dans un programme Cairo et qu’une fois le reçu divulgué en public, aucun secret n’est exposé.
À s’avoir que cette fonction n’est pas encore déployé, mais probablement à l’avenir.
Cette page a été rédigé à l’aide de x et sur la base d’article et de documentations basés ci-dessous
En apprendre plus sur Cairo :
Site Officiel | Documentation | Cairo Paper | Guide ressources | Hello, Cairo | How Cairo Works