Initialement publié en anglais par StarkWare le 24 novembre, 2022

TL;DR

• Cairo 1.0 est open source ! C'est seulement la première étape vers la mise en open source de la stack technologique de Starknet.

• Nous présentons maintenant un premier aperçu du compilateur Cairo 1.0. Vous pouvez maintenant commencer à expérimenter avec le code de base Cairo 1.0

• Cairo 1.0, dans son essence, est très similaire à Rust

• Considérez cela comme un avant-goût et non une version finale. D'autres améliorations sont en cours. La première version du compilateur est prévue pour le début du premier trimestre de l'année prochaine.

• Cairo 1.0 n'est pas encore pris en charge sur Starknet. Il sera pris en charge sur Starknet au premier trimestre de l'année prochaine.

Introduction

En 2020, nous avons publié Cairo, un langage de programmation Turing-complet prenant en charge le calcul vérifiable. Cairo a commencé comme un langage d'assemblage et est devenu progressivement plus expressif. Il y a deux mois, nous avons annoncé Cairo 1.0, qui résout certains problèmes majeurs dans la situation actuelle :

• Bien que la syntaxe de Cairo ait connu des améliorations significatives depuis sa création, l'expérience de développement peut toujours s'améliorer. Cairo 1.0 est un langage entièrement typé et inspiré de Rust, rendant l'écriture d’une même logique beaucoup plus facile et moins sujette aux erreurs.

• Le compilateur existant est développé dans le même repo que Starknet lui-même, ce qui rend plus difficile le suivi des modifications du langage. Le compilateur Cairo 1.0 est écrit à partir de zéro, permettant un développement plus rapide des fonctionnalités et laisse place à une participation plus importante de la communauté.

• Chaque calcul est maintenant prouvable. Actuellement, un programme Cairo peut échouer avec des entrées (inputs) spécifiques (par exemple, en atteignant une instruction assert 1=2 dans une branche de calcul), rendant le calcul non prouvable. Avec Cairo 1.0, les programmes sont prouvables dans chaque branche possible. Cela est particulièrement important pour la protection contre les attaques DoS et la résistance à la censure.

Aujourd'hui, nous marquons la première étape pour atteindre les objectifs ci-dessus en transférant le développement vers un repo public rendant ainsi Cairo 1.0 open source ! Les développeurs peuvent maintenant, pour la première fois, compiler et exécuter des programmes Cairo 1.0 simples. Cela permet aux développeurs de commencer à expérimenter avec Cairo 1.0 et de s'habituer progressivement aux nouvelles fonctionnalités, même s'ils ne peuvent pas encore l'implémenter sur Starknet à ce stade.

Capacités actuelles

Actuellement, vous pouvez compiler et exécuter des programmes Cairo natifs de base. Bien que de nombreuses améliorations de syntaxe/langage soient encore en cours, cela permet de se familiariser avec Cairo 1.0 et de profiter des mises à niveau au fur et à mesure de leur arrivée.

Notez que l'écriture de contrats Starknet n'est pas encore prise en charge. Les syntaxes de Starknet tel que : variables de stockage / appels de contrats / événements et autres appels système, seront ajoutées dans les semaines à venir.

Exemples de code

Pour illustrer les différences entre l'ancienne syntaxe et Cairo 1.0, nous avons choisi de montrer quelques implémentations/avant-goût différentes pour trouver le n-ième nombre de Fibonacci.

Exemple I : expressions de correspondance

Dans Cairo 1.0, vous pouvez utiliser des expressions de correspondance (match) similaires à Rust. Vous n'aurez plus à craindre les instructions if/else qui pourraient entraîner une révocation de référence !

Exemple II : Types de données

Alors que Cairo 0 travaillait avec des "felts" et des “pointers”, dans Cairo 1.0, nous avons un accès natif à des types de données complexes dans le langage. Vous trouverez ci-dessous un exemple qui génère un tableau des n premiers nombres de Fibonacci.

Comme vous pouvez le voir ci-dessus, au lieu de travailler directement avec des pointers mémoire, nous utilisons le type de variable Array::<felt> et la fonction array_append.

Exemple III : Structures et propriété

Le code suivant illustre l'utilisation de structures dans Cairo 1.0.

Le paragraphe suivant est destiné aux adeptes de Rust parmi l'audience. Cairo 1.0 gère la mémoire d’une manière similaire à Rust. En particulier, il utilise les concepts de ownership and borrowing.. Ainsi, en accédant à un membre de la structure FibResult (dans ce cas, result.value), nous avons déplacé result, ce qui signifie, à moins que FibResult ne soit copiable, nous ne pouvons plus y accéder dans result.index. Pour surmonter cela, nous ajoutons l'attribut #[derive(Copy)] au type de variable FibResult. Dans les versions futures, nous ajouterons une déconstruction automatique pour les structures. Cela permettra de transférer la propriété d'un membre sans toucher aux autres (en particulier, le code ci-dessus compilerait même si FibResult n'avait pas l'attribut de copie).

En particulier, notez que Cairo 1.0 abstrait complètement le modèle de mémoire original (lecture seule non déterministe) de Cairo.

Exemple IV : Propagation des erreurs

Le code suivant calcule le n-ième nombre de Fibonacci, mais contrairement aux exemples précédents, toutes les entrées sont de type uint128. Notez que cela résout un problème majeur de manipulation des entiers dans Cairo 0. Ici, uint128 (et à l'avenir uint256) sont des types de variables natifs.

L'addition de deux entiers de 128 bits peut entraîner des débordements. Le code ci-dessus utilise Option enum et l'opérateur pointe vers l'interrogation pour gérer les cas de débordements dans l'une des additions intermédiaires. Comparez cela à la syntaxe actuelle d'addition de uint256, où la fonction unit256_check devait être appelée pour garantir l'intégrité. De plus, dans un avenir proche, nous ajouterons le concept panic au langage (similaire à la macro panic en Rust). Ainsi des erreurs simples telles que les débordements d'addition ne pourront pas être interceptés et propagées automatiquement, signifiant que vous n'aurez pas à utiliser Option ou ? lors de l'addition d’uints.

Essayez par vous-même

Vous pouvez maintenant compiler et exécuter des programmes Cairo 1.0 actuellement pris en charge ! Suivez ces instructions sur la façon d'utiliser la commande cairo-run. Notez qu'en interne, la machine virtuelle Cairo Rust, développée par Lambdaclass, est utilisée pour l'exécution.

Vous pouvez trouver plus d'exemples pour vous aider à démarrer ici. Notez que ce n'est qu'un premier aperçu du développement du compilateur; dans les semaines à venir, nous améliorerons l'interface en ligne de commande (CLI) ainsi que le compilateur.

Projets futurs

L'objectif de la première version du compilateur, prévue pour le début du premier trimestre, est de prendre en charge toutes les fonctionnalités existantes de Starknet dans Cairo 1.0. De plus, nous travaillons à étendre les capacités du compilateur Cairo 1.0. Dans les semaines à venir, vous pouvez vous attendre à :

• Les fonctionnalités de Starknet - écrire des contrats intelligents et utiliser des appels système

• Des boucles (Loops)

• De nouvelles fonctions de bibliothèque

• Une amélioration du serveur de langage

• Une notion native de gas Starknet

Assurez-vous de rester à l'écoute et de suivre les progrès du compilateur !