Passer au contenu principal
Change page

Les langages des contrats intelligents

Dernière mise à jour de la page : 26 février 2026

DylanCONINDopens in a new tab
MATsxmMopens in a new tab
KlerKopens in a new tab
+22

Un aspect important d'Ethereum est que les contrats intelligents peuvent être programmés en utilisant des langages relativement conviviaux pour les développeurs. Si vous avez de l'expérience avec Python ou tout langage à accoladesopens in a new tab, vous pouvez trouver un langage avec une syntaxe familière.

Les deux langages les plus actifs et les plus suivis sont :

  • solidity
  • Vyper

L'IDE Remix fournit un environnement de développement complet pour créer et tester des contrats dans Solidity et Vyper. Essayez l'IDE Remix dans le navigateuropens in a new tab pour commencer à coder.

Les développeurs plus expérimentés peuvent également utiliser Yul, un langage intermédiaire pour la machine virtuelle Ethereum, ou Yul+, une extension de Yul.

Si vous êtes curieux et que vous aimez aider à tester de nouveaux langages encore en cours de développement, vous pouvez essayer Fe, un nouveau langage pour contrat intelligent qui en est encore à ses balbutiements.

Prérequis

La connaissance de langages de programmation comme JavaScript ou Python peut vous aider à comprendre les différences entre les langages de contrats intelligents. Nous vous conseillons également d'avoir compris le concept des contrats intelligents avant de vous plonger dans les comparaisons entre les différents langages. Introduction aux contrats intelligents.

Solidity

  • Un langage orienté objet et de haut niveau pour la mise en œuvre de contrats intelligents.
  • Un langage à accolades principalement influencé par C++.
  • Typé statiquement (le type d'une variable est connu au moment de la compilation)
  • Prend en charge les éléments suivants :
    • Héritage : Vous pouvez prolonger d'autres contrats.
    • Bibliothèques : Vous pouvez créer du code réutilisable que vous pouvez appeler à partir de différents contrats, comme les fonctions statiques d'une classe statique dans d'autres langages de programmation orientés objets.
    • Types complexes défini par l'utilisateur

Liens importants

Exemple de contrat

1// SPDX-License-Identifier: GPL-3.0
2pragma solidity >= 0.7.0;
3
4contract Coin {
5    // Le mot-clé « public » rend les variables
6    // accessibles depuis d'autres contrats
7    address public minter;
8    mapping (address => uint) public balances;
9
10    // Les événements permettent aux clients de réagir aux modifications spécifiques
11    // du contrat que vous déclarez
12    event Sent(address from, address to, uint amount);
13
14    // Le code du constructeur n'est exécuté que lors de la création
15    // du contrat
16    constructor() {
17        minter = msg.sender;
18    }
19
20    // Envoie un montant de pièces nouvellement créées à une adresse
21    // Ne peut être appelé que par le créateur du contrat
22    function mint(address receiver, uint amount) public {
23        require(msg.sender == minter);
24        require(amount < 1e60);
25        balances[receiver] += amount;
26    }
27
28    // Envoie un montant de pièces existantes
29    // depuis n'importe quel appelant vers une adresse
30    function send(address receiver, uint amount) public {
31        require(amount <= balances[msg.sender], "Solde insuffisant.");
32        balances[msg.sender] -= amount;
33        balances[receiver] += amount;
34        emit Sent(msg.sender, receiver, amount);
35    }
36}
Afficher tout

Cet exemple devrait vous donner une idée de la syntaxe d'un contrat Solidity. Pour une description plus détaillée des fonctions et des variables, consultez la documentationopens in a new tab.

Vyper

  • Langage de programmation pythonique
  • Typage fort
  • Code de compilation concis et compréhensible
  • Génération efficace du bytecode
  • A intentionnellement moins de fonctionnalités que Solidity dans le but de rendre les contrats plus sécurisés et plus faciles à auditer. Vyper ne prend pas en charge les éléments suivants :
    • Modificateurs
    • Héritage
    • Assemblage en ligne
    • Surcharge des fonctions
    • Surcharge d’opérateur
    • Appels récurrents
    • Boucles infinies
    • Points fixes binaires

Pour plus d'informations, lisez la raison d'être de Vyperopens in a new tab.

Liens importants

Exemple

1# Enchère ouverte
2
3# Paramètres de l'enchère
4
5# Le bénéficiaire reçoit l'argent du plus offrant
6
7beneficiary: public(address)
8auctionStart: public(uint256)
9auctionEnd: public(uint256)
10
11# État actuel de l'enchère
12
13highestBidder: public(address)
14highestBid: public(uint256)
15
16# Mis à « true » à la fin, interdit toute modification
17
18ended: public(bool)
19
20# Suivi des enchères remboursées afin que nous puissions suivre le modèle de retrait
21
22pendingReturns: public(HashMap[address, uint256])
23
24# Crée une enchère simple avec un temps d'enchère de `_bidding_time`
25
26# secondes pour le compte de
27
28# l'adresse du bénéficiaire `_beneficiary`.
29
30@external
31def __init__(_beneficiary: address, _bidding_time: uint256):
32    self.beneficiary = _beneficiary
33    self.auctionStart = block.timestamp
34    self.auctionEnd = self.auctionStart + _bidding_time
35
36# Enchérir sur l'enchère avec la valeur envoyée
37
38# avec cette transaction.
39
40# La valeur ne sera remboursée que si
41
42# l'enchère n'est pas remportée.
43
44@external
45@payable
46def bid():
47    # Vérifie si la période d'enchères est terminée.
48    assert block.timestamp < self.auctionEnd
49    # Vérifie si l'enchère est suffisamment élevée
50    assert msg.value > self.highestBid
51    # Suivi du remboursement de l'enchérisseur le plus élevé précédent
52    self.pendingReturns[self.highestBidder] += self.highestBid
53    # Suivi de la nouvelle enchère la plus élevée
54    self.highestBidder = msg.sender
55    self.highestBid = msg.value
56
57# Retirer une enchère précédemment remboursée. Le modèle de retrait est
58
59# utilisé ici pour éviter un problème de sécurité. Si les remboursements étaient directement
60
61# envoyés dans le cadre de bid(), un contrat d'enchères malveillant pourrait bloquer
62
63# ces remboursements et ainsi empêcher l'arrivée de nouvelles enchères plus élevées.
64
65@external
66def withdraw():
67    pending_amount: uint256 = self.pendingReturns[msg.sender]
68    self.pendingReturns[msg.sender] = 0
69    send(msg.sender, pending_amount)
70
71# Met fin à l'enchère et envoie l'enchère la plus élevée
72
73# au bénéficiaire.
74
75@external
76def endAuction():
77    # Il est recommandé de structurer les fonctions qui interagissent
78    # avec d'autres contrats (c'est-à-dire qu'elles appellent des fonctions ou envoient de l'ether)
79    # en trois phases :
80    # 1. vérification des conditions
81    # 2. exécution d'actions (pouvant modifier les conditions)
82    # 3. interaction avec d'autres contrats
83    # Si ces phases sont mélangées, l'autre contrat pourrait rappeler
84    # le contrat actuel et modifier l'état ou provoquer
85    # des effets (paiement d'ether) à effectuer plusieurs fois.
86    # Si les fonctions appelées en interne incluent une interaction avec des contrats
87    # externes, elles doivent également être considérées comme une interaction avec des
88    # contrats externes.
89
90    # 1. Conditions
91    # Vérifie si l'heure de fin de l'enchère a été atteinte
92    assert block.timestamp >= self.auctionEnd
93    # Vérifie si cette fonction a déjà été appelée
94    assert not self.ended
95
96    # 2. Effets
97    self.ended = True
98
99    # 3. Interaction
100    send(self.beneficiary, self.highestBid)
Afficher tout

Cet exemple devrait vous donner une idée de la syntaxe d'un contrat Vyper. Pour une description plus détaillée des fonctions et des variables, consultez la documentationopens in a new tab.

Yul et Yul+

Si vous débutez avec Ethereum et que vous n'avez pas encore jamais codé avec des langages de contrats intelligents, nous vous recommandons de commencer avec Solidity ou Vyper. Intéressez-vous à Yul ou Yul+ seulement une fois que vous êtes familiarisé avec les bonnes pratiques de sécurité pour les contrats intelligents et les spécificités de l'EVM.

Yul

  • Langage intermédiaire pour Ethereum
  • Prend en charge l'EVM et l'Ewasmopens in a new tab, un WebAssembly aux couleurs d'Ethereum, et est conçu pour être un dénominateur commun utilisable des deux plateformes.
  • Bonne cible pour les étapes d'optimisation de haut niveau qui peuvent bénéficier de la même manière aux plateformes EVM et Ewasm.

Yul+

  • Extension de Yul de bas niveau très efficace
  • Initialement conçu pour un contrat de rollup optimiste.
  • Yul+ peut être considéré comme une proposition de mise à niveau expérimentale de Yul, qui y ajoute de nouvelles fonctionnalités

Liens importants

Exemple de contrat

Cet exemple simple implémente une fonction puissance. Il peut être compilé en utilisant solc --strict-assembly --bin input.yul. et devrait être stocké dans le fichier input.yul.

1{
2    function power(base, exponent) -> result
3    {
4        switch exponent
5        case 0 { result := 1 }
6        case 1 { result := base }
7        default
8        {
9            result := power(mul(base, base), div(exponent, 2))
10            if mod(exponent, 2) { result := mul(base, result) }
11        }
12    }
13    let res := power(calldataload(0), calldataload(32))
14    mstore(0, res)
15    return(0, 32)
16}
Afficher tout

Si vous avez déjà une bonne expérience des contrats intelligents, une implémentation complète d'ERC20 dans Yul peut être trouvée iciopens in a new tab.

Fe

  • Langage statique pour la Machine Virtuelle Ethereum (EVM).
  • Inspiré par Python et Rust.
  • Son objectif est d'être facile à apprendre, même pour les développeurs qui sont nouveaux dans l'écosystème Ethereum.
  • Le développement de Fe en est encore à ses débuts, le langage a connu sa version alpha en janvier 2021.

Liens importants

Exemple de contrat

Ceci est un simple contrat implémenté dans Fe.

1type BookMsg = bytes[100]
2
3contract GuestBook:
4    pub guest_book: map<address, BookMsg>
5
6    event Signed:
7        book_msg: BookMsg
8
9    pub def sign(book_msg: BookMsg):
10        self.guest_book[msg.sender] = book_msg
11
12        emit Signed(book_msg=book_msg)
13
14    pub def get_msg(addr: address) -> BookMsg:
15        return self.guest_book[addr].to_mem()
16
Afficher tout

Comment choisir

Comme pour tout autre langage de programmation, il s'agit surtout de choisir le bon outil en fonction du travail à effectuer et des préférences personnelles.

Voici quelques éléments à considérer si vous n'en avez encore essayé :

Quels sont les avantages de Solidity ? Avantages de Solidity

  • Si vous débutez, il existe de nombreux tutoriels et outils d'apprentissage. Pour en savoir plus, consultez la section Apprendre en codant.
  • De bons outils de développement sont disponibles.
  • Solidity dispose d'une importante communauté de développeurs, ce qui signifie que vous obtiendrez probablement des réponses à vos questions très rapidement.

Quels sont les avantages de Vyper ? Avantages de Vyper

  • Excellent moyen de commencer pour les développeurs Python qui veulent rédiger des contrats intelligents.
  • Vyper dispose d'un nombre plus restreint de fonctionnalités, ce qui en fait un langage idéal pour un prototypage rapide des idées.
  • Il est conçu de façon à être facile à contrôler et extrêmement lisible pour l'être humain.

Quels sont les avantages de Yul et Yul+ ? Avantages de Yul

  • Language simple et fonctionnel de bas niveau.
  • Permet de se rapprocher au plus près de l'EVM brute, ce qui peut aider à optimiser l'utilisation du gaz de vos contrats.

Comparaisons des langages

Pour des comparaisons de la syntaxe de base, du cycle de vie du contrat, des interfaces, des opérateurs, des structures de données, des fonctions, du flux de contrôle et plus encore, consultez cet aide-mémoire d'Auditlessopens in a new tab

En savoir plus

Cet article vous a été utile ?