# Cairo 1.0

By [Starknet France](https://paragraph.com/@starknet-france) · 2022-09-14

---

[_Initialement publié_](https://medium.com/starkware/cairo-1-0-aa96eefb19a0) _en anglais par StarkWare le 12 septembre, 2022._

![](https://storage.googleapis.com/papyrus_images/1b6e11567db6649fec7d17cb1f504b499a8dcb1ae2269e0ca43f111c69c22ac2.png)

### TL;DR

*   Cairo 1.0 est la première version majeure après l’introduction de Cairo il y a deux ans
    
*   Cairo 1.0 donnera aux développeurs un langage de programmation plus sûr, plus simple et plus conviviale
    
*   Au cœur de Cairo 1.0 se trouvera **Sierra**, une couche de représentation intermédiaire qui promet une plus grande stabilité à long terme pour les programmes Cairo.
    
*   Sierra fait progresser Cairo pour servir dans un réseau permissionless :
    
    *   **Protéger le réseau** : il permet une protection DoS plus robuste
        
    *   **Protéger l’utilisateur** : il permet un censorship resistance de même niveau qu’Ethereum
        
*   Cairo 1.0 affectera StarkNet de plusieurs façons. Cela aura aussi un effet sur [Regenesis](https://mirror.xyz/0x568B12eBBE85521D2cd8a2C9B7a8EF3f48aa2d66/YVTohytluoAAcYZLqzAiOqghXFIMTjurQmwsRcJlwXM). Nous publierons plus d’informations sur Regenesis dans les prochaines semaines.
    

### Introduction

En 2020, nous avons sorti Cairo, un langage de programmation Turing-complet, et avons fait un grand pas vers la prise en charge du calcul vérifiable avec STARKs. Aujourd’hui, nous annonçons Cairo 1.0, la plus grande avancée de Cairo à ce jour. Il introduira un langage amélioré, avec des fonctionnalités qui amélioreront la convivialité, la sécurité et la commodité. Il est conçu pour soutenir les besoins de StarkNet en tant que réseau permissionless, permettant au protocole de devenir plus simple et plus sûr. Le développement est déjà en cours, et nous espérons que la première version aura lieu prochainement.

Dans cet article, nous allons décrire le voyage de Cairo jusqu’à présent et partager les détails sur les prochaines fonctionnalités.

### La voyage de Cairo

Jusqu’en 2020, des connaissances de niche étaient nécessaires pour construire des programmes de calcul général vérifiables par STARK. Ce n’était possible que pour ceux qui comprenaient les mathématiques complexes derrière STARKs. Plus précisément, pour chaque business logic, c’est-à-dire chaque calcul, il fallait générer une représentation algébrique intermédiaire (AIR) – un ensemble de contraintes polynomiales représentant le calcul spécifique.

Cairo est né de la prise de conscience que le calcul vérifiable devrait être mis à la disposition des développeurs du monde entier. Cairo permet aux développeurs d’exploiter la puissance des STARKs.

La communauté des développeurs a depuis saisi Cairo pour construire avec enthousiasme. Tout dans l’écosystème florissant de StarkNet aujourd’hui est basé sur Cairo. Entre [StarkNet](https://starkware.co/starknet/) et [StarkEx](https://starkware.co/starkex/), Cairo alimente ses applications qui ont traité plus de 220M transactions, mint plus de 65M NFTs, et manipulé $700B de transactions, tous réglés sur Ethereum.

Bien que Cairo ait rendu STARKs accessibles, il a été conçu à l’origine comme un langage d’assemblage, et en tant que tel, il a été écrit comme un langage de bas niveau.

![Un exemple pour les premiers programmes qui ont été écrits en Cairo](https://storage.googleapis.com/papyrus_images/8b665d3b78b89ce0a236f36b75165bf4a4be1aafc1eb9e153d87311607600908.png)

Un exemple pour les premiers programmes qui ont été écrits en Cairo

Encouragés par les commentaires des développeurs et la montée de [StarkNet](https://starkware.co/starknet/), nous avons progressivement rendu Cairo plus expressif et plus convivial pour les développeurs.

![Un exemple du contrat ERC-20 de Cairo démontrant la prise en charge des variables, des instructions, des erreurs et de la librairie UINT256](https://storage.googleapis.com/papyrus_images/8b665d3b78b89ce0a236f36b75165bf4a4be1aafc1eb9e153d87311607600908.png)

Un exemple du contrat ERC-20 de Cairo démontrant la prise en charge des variables, des instructions, des erreurs et de la librairie UINT256

Mais nous avons vite conclu qu’il était temps de faire un grand bond en avant et, au lieu d’améliorer progressivement la situation de Cairo, opter pour une transformation plus audacieuse.

### Cairo 1.0

Pour Cairo 1.0, nous avons construit un tout nouveau compilateur à partir de zéro, qui fournira aux développeurs des fonctionnalités de sécurité, et leur permettra d’écrire des contrats d’une manière plus simple et plus expressive.

**Présentation de Sierra : s’assurer que chaque exécution de Cairo peut être prouvée**

Le principal ajout de Cairo 1.0 est Sierra (**S**afe **I**nt**e**rmediate **R**ep**r**esent**a**tion). Sierra constitue une nouvelle couche de représentation intermédiaire entre Cairo 1.0 et le byte code Cairo. L’objectif de Sierra est de s’assurer que chaque exécution de Cairo – c’est-à-dire un programme de Cairo et ses apports – puisse être prouvée (voir plus bas).

Sierra promet aux développeurs Cairo une meilleur code à l’épreuve sur l’avenir. Une plus grande stabilité est fournie par le fait que les contrats StarkNet n’auront pas besoin de recompiler en cas d’amélioration du système sous-jacent (par exemple, modifications de l’architecture CPU AIR, améliorations de la traduction finale de Sierra vers le bytecode Cairo).

**Prouver toutes les exécutions de Cairo**. Dans l’ancien Cairo, une exécution de Cairo peut entraîner trois cas – VRAI, FAUX, ou échec. Les exécutions ratées ne peuvent pas être prouvées. Sierra, garantit qu’une exécution de Cairo n’échouera jamais, et ne peut aboutir qu’à VRAI ou FAUX. Cela garantit à son tour que chaque exécution de Cairo peut être prouvée.

Cette introduction de Sierra a des implications importantes pour StarkNet en tant que réseau permissionless. Sierra garantit que même les transactions inversées peuvent être incluses dans les blocs StarkNet. Cette propriété permettra au protocole StarkNet de rester allégé et simple sans qu’il soit nécessaire d’ajouter des mécanismes crypto-économiques complexes.

Deux exemples significatifs :

1.  Les séquenceurs pourront percevoir des frais sur les transactions annulées, ce qui permettra à StarkNet d’empêcher le séquenceur DoS d’une manière bien établie.
    
2.  La mise en œuvre forcée des transactions L1 sera possible, permettant à StarkNet d’hériter du censorship-resistance complet d’Ethereum.
    

### Caractéristique du langage

Cairo 1.0 offrira de nombreuses améliorations au langage de programmation lui-même. Tout ce qui est listé ci-dessous ne fera pas partie de la première version, mais il fait partie de la roadmap.

**Amélioration de la syntaxe**

*   Plus de _local_ et de _tempvar_. Nous n’avons plus qu’à les laisser régir toutes les variables.
    
*   Amélioration de la syntaxe _if_
    
        Old
        
        if cond != 0 {
          tempvar x = x+1;
        } else {
          tempvar x = x;
        }
        __________________________________
        
        New
        
        if cond { x = x + 1; }
        
    
    **Plus facile d’utiliser les constructions de langage**
    
*   **Type de sécurité garanties**
    
    Le compilateur utilisera une tape forte pour améliorer la sécurité du code. Par exemple :
    
    *   Les pointeurs pointent toujours vers la mémoire initialisée.
        
    *   Les dictionnaires seront toujours écrasés, au lieu de laisser la responsabilité d’appeler `squash_dict` au programmeur.
        

**Plus facile d’utiliser les constructions de langage**

Par exemple :

*   Pour boucles (loops)
    
    `let sum = 0`
    

`for x in iter {` `sum = sum + x;` `}`

*   Expressions booléennes
    
*   Des entiers (avec division d’entiers réguliers)
    
*   Overflow protection pour les types concernés
    
*   Conditions booléennes
    
    `Old`
    
    `If cond1:`
    
    `if cond2:`
    
    `# Some code`
    
    `else if cond3:`
    
    `# Same code`
    
    `__________________________________`
    
    `New`
    
    `If cond1 && (cond2 || cond3) { … }`
    

**Un système de type à part entière**

*   Types de données abstraites (càd semblable à Rust enum)
    

    enum Option<T> {
     Some: T,
     None,
    }
    
    match result {
     Some(r) => {..},
     None => {..},
    }
    

*   Traits
    

    trait Add<Uint256> {
        fn add(…) { … }
    }
    
    let a: Uint256 = 1;
    let b: Uint256 = 4;
    a + b; // Evaluated to 5 of type Uint256.
    

**Des librairies plus intuitives**

(par exemple, dict, arrays)

*   Dict<Uint256, MyStruct> ;
    
*   Array ;
    
*   **Un Code plus optimisé**
    
    Pas besoin d’indiquer explicitement l’allocation des variables locales – auto détectée et effectuée automatiquement.
    
    **Meilleure intégration du compilateur**
    
    Permettre un meilleur soutien à l’IDE, une meilleure gestion des paquets et une meilleure facilitation des contributions communautaires.
    
    ### Conclusion
    
    Deux ans après la première utilisation de Cairo en production, nous développons Cairo 1.0, qui améliorera l’expression, la sécurité et la syntaxe. Il prendra un grand pas en avant, permettant aux développeurs d’écrire plus facilement leurs contrats StarkNet.
    
    Dans un autre post, à venir, nous partagerons plus de détails sur la façon dont Cairo 1.0 va effectuer la régénération de StarkNet, et comment les développeurs doivent se préparer à sa sortie.
    
    _Traduction faite par_ [_@cleminso_](https://twitter.com/cleminso)

---

*Originally published on [Starknet France](https://paragraph.com/@starknet-france/cairo-1-0)*