Langages des contrats intelligents

Un aspect formidable 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 autre langage à accolades (s'ouvre dans un nouvel onglet), vous pourrez trouver un langage avec une syntaxe familière.

Les deux langages les plus actifs et maintenus sont :

Solidity
Vyper

L'environnement de développement intégré (EDI) Remix fournit un environnement de développement complet pour créer et tester des contrats en Solidity et Vyper. Essayez l'EDI Remix dans votre navigateur (s'ouvre dans un nouvel onglet) pour commencer à coder.

Les développeurs plus expérimentés pourraient également vouloir utiliser Yul, un langage intermédiaire pour la Machine Virtuelle Ethereum (EVM), ou Yul+, une extension de Yul.

Si vous êtes curieux et aimez aider à tester de nouveaux langages qui sont encore en plein développement, vous pouvez expérimenter avec Fe, un langage de contrats intelligents émergent qui en est encore à ses balbutiements.

Prérequis

Une connaissance préalable des langages de programmation, en particulier de JavaScript ou Python, peut vous aider à comprendre les différences entre les langages de contrats intelligents. Nous vous recommandons également de comprendre le concept des contrats intelligents avant de vous plonger trop profondément dans les comparaisons de langages. Introduction aux contrats intelligents.

Solidity

Langage de haut niveau orienté objet pour l'implémentation de contrats intelligents.
Langage à accolades qui a été le plus profondément influencé par C++.
Typage statique (le type d'une variable est connu au moment de la compilation).
Prend en charge :
- L'héritage (vous pouvez étendre d'autres contrats).
- Les bibliothèques (vous pouvez créer du code réutilisable que vous pouvez appeler depuis différents contrats – comme des fonctions statiques dans une classe statique dans d'autres langages de programmation orientés objet).
- Les types complexes définis par l'utilisateur.

Liens importants

Exemple de contrat

// SPDX-License-Identifier: GPL-3.0
pragma solidity >= 0.7.0;

contract Coin {
    // Le mot-clé "public" rend les variables
    // accessibles depuis d'autres contrats
    address public minter;
    mapping (address => uint) public balances;

    // Les événements permettent aux clients de réagir à des
    // changements de contrat spécifiques que vous déclarez
    event Sent(address from, address to, uint amount);

    // Le code du constructeur n'est exécuté que lorsque le contrat
    // est créé
    constructor() {
        minter = msg.sender;
    }

    // Envoie une quantité de pièces nouvellement créées à une adresse
    // Ne peut être appelé que par le créateur du contrat
    function mint(address receiver, uint amount) public {
        require(msg.sender == minter);
        require(amount < 1e60);
        balances[receiver] += amount;
    }

    // Envoie une quantité de pièces existantes
    // de n'importe quel appelant à une adresse
    function send(address receiver, uint amount) public {
        require(amount <= balances[msg.sender], "Insufficient balance.");
        balances[msg.sender] -= amount;
        balances[receiver] += amount;
        emit Sent(msg.sender, receiver, amount);
    }
}

Cet exemple devrait vous donner une idée de ce à quoi ressemble la syntaxe d'un contrat Solidity. Pour une description plus détaillée des fonctions et des variables, consultez la documentation (s'ouvre dans un nouvel onglet).

Vyper

Langage de programmation de style Python (Pythonic)
Typage fort
Code du compilateur petit et compréhensible
Génération efficace de bytecode
Possède délibérément 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 modificateurs (modifiers)
- L'héritage
- L'assembleur en ligne (inline assembly)
- La surcharge de fonctions
- La surcharge d'opérateurs
- Les appels récursifs
- Les boucles de longueur infinie
- Les virgules fixes binaires

Depuis la v0.4.0, Vyper prend en charge un système de modules (s'ouvre dans un nouvel onglet). La réutilisation du code est obtenue par composition, plutôt que par héritage de classes.

Pour plus d'informations, lisez la justification de Vyper (s'ouvre dans un nouvel onglet).

Liens importants

Exemple

# Enchère ouverte

# Paramètres de l'enchère
# Le bénéficiaire reçoit l'argent du meilleur enchérisseur
beneficiary: public(address)
auctionStart: public(uint256)
auctionEnd: public(uint256)

# État actuel de l'enchère
highestBidder: public(address)
highestBid: public(uint256)

# Défini sur true à la fin, interdit toute modification
ended: public(bool)

# Garder une trace des offres remboursées afin de pouvoir suivre le modèle de retrait
pendingReturns: public(HashMap[address, uint256])

# Crée une enchère simple avec `_bidding_time`
# secondes de temps d'enchère au nom de
# l'adresse du bénéficiaire `_beneficiary`.
@deploy
def __init__(_beneficiary: address, _bidding_time: uint256):
    self.beneficiary = _beneficiary
    self.auctionStart = block.timestamp
    self.auctionEnd = self.auctionStart + _bidding_time

# Enchérir sur l'enchère avec la valeur envoyée
# avec cette transaction.
# La valeur ne sera remboursée que si
# l'enchère n'est pas remportée.
@external
@payable
def bid():
    # Vérifier si la période d'enchère est terminée.
    assert block.timestamp < self.auctionEnd
    # Vérifier si l'offre est suffisamment élevée
    assert msg.value > self.highestBid
    # Suivre le remboursement pour le précédent meilleur enchérisseur
    self.pendingReturns[self.highestBidder] += self.highestBid
    # Suivre la nouvelle meilleure offre
    self.highestBidder = msg.sender
    self.highestBid = msg.value

# Retirer une offre précédemment remboursée. Le modèle de retrait est
# utilisé ici pour éviter un problème de sécurité. Si les remboursements étaient directement
# envoyés dans le cadre de bid(), un contrat d'enchère malveillant pourrait bloquer
# ces remboursements et ainsi empêcher l'arrivée de nouvelles offres plus élevées.
@external
def withdraw():
    pending_amount: uint256 = self.pendingReturns[msg.sender]
    self.pendingReturns[msg.sender] = 0
    send(msg.sender, pending_amount)

# Terminer l'enchère et envoyer la meilleure offre
# au bénéficiaire.
@external
def endAuction():
    # C'est une bonne pratique de structurer les fonctions qui interagissent
    # avec d'autres contrats (c'est-à-dire qu'elles appellent des fonctions ou envoient de l'ether)
    # en trois phases :
    # 1. vérification des conditions
    # 2. exécution des actions (modifiant potentiellement les conditions)
    # 3. interaction avec d'autres contrats
    # Si ces phases sont mélangées, l'autre contrat pourrait rappeler
    # le contrat actuel et modifier l'état ou faire en sorte que
    # des effets (paiement en ether) soient exécutés plusieurs fois.
    # Si les fonctions appelées en interne incluent une interaction avec des
    # contrats externes, elles doivent également être considérées comme une interaction avec
    # des contrats externes.

    # 1. Conditions
    # Vérifier si l'heure de fin de l'enchère a été atteinte
    assert block.timestamp >= self.auctionEnd
    # Vérifier si cette fonction a déjà été appelée
    assert not self.ended

    # 2. Effets
    self.ended = True

    # 3. Interaction
    send(self.beneficiary, self.highestBid)

Cet exemple devrait vous donner une idée de ce à quoi ressemble la syntaxe d'un contrat Vyper. Pour une description plus détaillée des fonctions et des variables, consultez la documentation (s'ouvre dans un nouvel onglet).

Yul et Yul+

Si vous êtes nouveau sur Ethereum et que vous n'avez encore jamais codé avec des langages de contrats intelligents, nous vous recommandons de commencer par Solidity ou Vyper. Ne vous penchez sur Yul ou Yul+ qu'une fois que vous serez familiarisé avec les meilleures pratiques de sécurité des contrats intelligents et les spécificités du travail avec l'EVM.

Yul

Langage intermédiaire pour Ethereum.
Prend en charge l'EVM et l'Ewasm (s'ouvre dans un nouvel onglet), un WebAssembly à la sauce Ethereum, et est conçu pour être un dénominateur commun utilisable pour les deux plateformes.
Bonne cible pour les étapes d'optimisation de haut niveau qui peuvent bénéficier de manière égale aux plateformes EVM et Ewasm.

Yul+

Une extension de bas niveau et très efficace pour Yul.
Initialement conçu pour un contrat de rollup optimiste.
Yul+ peut être considéré comme une proposition de mise à niveau expérimentale pour Yul, lui ajoutant de nouvelles fonctionnalités.

Liens importants

Exemple de contrat

L'exemple simple suivant implémente une fonction de puissance. Il peut être compilé en utilisant solc --strict-assembly --bin input.yul. L'exemple doit être stocké dans le fichier input.yul.

{
    function power(base, exponent) -> result
    {
        switch exponent
        case 0 { result := 1 }
        case 1 { result := base }
        default
        {
            result := power(mul(base, base), div(exponent, 2))
            if mod(exponent, 2) { result := mul(base, result) }
        }
    }
    let res := power(calldataload(0), calldataload(32))
    mstore(0, res)
    return(0, 32)
}

Si vous êtes déjà très expérimenté avec les contrats intelligents, une implémentation complète d'ERC-20 en Yul peut être trouvée ici (s'ouvre dans un nouvel onglet).

Fe

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

Liens importants

Exemple de contrat

Voici un contrat simple implémenté en Fe.

type BookMsg = bytes[100]

contract GuestBook:
    pub guest_book: map<address, BookMsg>

    event Signed:
        book_msg: BookMsg

    pub def sign(book_msg: BookMsg):
        self.guest_book[msg.sender] = book_msg

        emit Signed(book_msg=book_msg)

    pub def get_msg(addr: address) -> BookMsg:
        return self.guest_book[addr].to_mem()

Comment choisir

Comme pour tout autre langage de programmation, il s'agit principalement de choisir le bon outil pour le bon travail, ainsi que de préférences personnelles.

Voici quelques éléments à prendre en compte si vous n'avez encore essayé aucun de ces langages :

Quels sont les avantages de Solidity ?

Si vous êtes débutant, 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 possède une grande communauté de développeurs, ce qui signifie que vous trouverez très probablement des réponses à vos questions assez rapidement.

Quels sont les avantages de Vyper ?

Un excellent moyen de commencer pour les développeurs Python qui souhaitent écrire des contrats intelligents.
Vyper possède un nombre réduit de fonctionnalités, ce qui le rend idéal pour le prototypage rapide d'idées.
Vyper vise à être facile à auditer et le plus lisible possible par un humain.

Quels sont les avantages de Yul et Yul+ ?

Langage de bas niveau simpliste et fonctionnel.
Permet de se rapprocher beaucoup plus de l'EVM brute, ce qui peut aider à optimiser l'utilisation du gaz de vos contrats.

Comparaisons de langages

Pour des comparaisons sur la syntaxe de base, le cycle de vie des contrats, les interfaces, les opérateurs, les structures de données, les fonctions, le flux de contrôle, et plus encore, consultez cet aide-mémoire par Auditless (s'ouvre dans un nouvel onglet)

Langages des contrats intelligents

Prérequis

Solidity

Liens importants

Exemple de contrat

Vyper

Liens importants

Exemple

Yul et Yul+

Liens importants

Exemple de contrat

Fe

Liens importants

Exemple de contrat

Comment choisir

Quels sont les avantages de Solidity ?

Quels sont les avantages de Vyper ?

Quels sont les avantages de Yul et Yul+ ?

Comparaisons de langages

Lectures complémentaires