Précédent

Suivant

Comprendre les notions de base du langage

Effectué

Tous les contrats Solidity comprennent généralement ceci :

• Directives pragma
• Variables d’état
• Fonctions
• Événements

Même s’il y a d’autres choses à savoir pour programmer des contrats intelligents de niveau production, ces concepts de base devraient vous aider à prendre un bon départ.

Si vous les maîtrisez, vous pourrez commencer tout de suite à écrire des contrats intelligents pour tout un éventail de cas d’usage.

Directives pragma

Pragma est le mot clé que vous utilisez pour demander au compilateur de vérifier si sa version de Solidity correspond à celle qui est nécessaire. Une correspondance signifie que votre fichier source peut s’exécuter correctement. Si la version ne correspond pas, le compilateur va générer une erreur.

Veillez toujours à inclure la dernière version de Solidity dans votre définition de contrat. Pour obtenir la version actuelle de Solidity, visitez son site web. Utilisez la version la plus récente dans votre fichier source.

Une directive pragma de version ressemble à ceci :

pragma solidity ^0.7.0;

Cette ligne signifie que le fichier source va se compiler avec un compilateur dont la version est supérieure à 0.7.0 et peut aller jusqu’à 0.7.9. À compter de la version 0.8.0, des changements cassants auront probablement été introduits que le fichier source ne pourra pas compiler correctement.

Variables d’état

Les variables d’état sont essentielles à tout fichier source Solidity. Les valeurs des variables d’état sont stockées de manière permanente dans le stockage de contrat.

pragma solidity >0.7.0 <0.8.0;

contract Marketplace {
    uint price; // State variable  

Notes

Les fichiers sources de contrat commencent toujours par la définition contract ContractName.

Dans cet exemple, la variable d’état est nommée price avec le type uint. Le type entier uint indique que cette variable est un entier non signé de 256 bits. Cela signifie qu’il peut stocker des nombres positifs compris dans la plage allant de 0 à 2²⁵⁶ -1.

Pour toutes les définitions de variable, vous devez spécifier le type et le nom de la variable.

De plus, vous pouvez spécifier la visibilité d’une variable d’état comme ceci :

• public : la variable d’état fait partie de l’interface du contrat et elle est accessible à partir d’autres contrats.
• internal : accessible en interne uniquement à partir du contrat actuel.
• private : visible uniquement pour le contrat dans lequel elle est définie.

Fonctions

Dans un contrat, les unités de code exécutables sont appelées fonctions. Les fonctions décrivent une action unique pour accomplir une seule tâche. Elles sont réutilisables et peuvent également être appelées à partir d’autres fichiers sources, comme des bibliothèques. Dans Solidity, les fonctions se comportent de la même façon que celles d’autres langages de programmation.

Voici un exemple de base de définition d’une fonction :

pragma solidity >0.7.0 <0.8.0;

contract Marketplace {
    function buy() public {
        // ...
    }
}

Ce code montre une fonction portant le nom buy dont la visibilité est publique, ce qui signifie qu’elle est accessible par d’autres contrats. Les fonctions peuvent utiliser l’un des spécificateurs de visibilité suivants : public, private, internal et external.

Une fonction peut être appelée en interne ou en externe à partir d’un autre contrat. Les fonctions peuvent accepter des paramètres et retourner des variables pour se passer des paramètres et des valeurs entre elles.

Voici un exemple de fonction qui accepte un paramètre (un entier appelé price) et qui retourne un entier :

pragma solidity >0.7.0 <0.8.0;

contract Marketplace {
    function buy(uint price) public returns (uint) {
        // ...
    }
}

Modificateurs de fonction

Des modificateurs de fonction peuvent être utilisés pour modifier le comportement des fonctions. Ils fonctionnent en vérifiant une condition avant l’exécution de la fonction. Par exemple, une fonction peut vérifier que seul un utilisateur désigné comme vendeur peut lister un article à vendre.

pragma solidity >0.7.0 <0.8.0;

contract Marketplace {
    address public seller;

    modifier onlySeller() {
        require(
            msg.sender == seller,
            "Only seller can put an item up for sale."
        );
        _;
    }

    function listItem() public view onlySeller {
        // ...
    }
}

Cet exemple présente les éléments suivants :

• Une variable de type address qui stocke l’adresse Ethereum à 20 octets de l’utilisateur vendeur. Vous en apprendrez davantage sur ces variables plus loin dans ce module.
• Un modificateur appelé onlySeller qui stipule que seul un vendeur peut lister un article.
• Un symbole spécial _; pour indiquer l’emplacement auquel le corps de la fonction est inséré.
• Une définition de fonction qui utilise le modificateur onlySeller.

Les autres modificateurs de fonction utilisables dans la définition de fonction sont les suivants :

• pure pour décrire les fonctions qui n’autorisent pas de modifications ni d’accès à l’état.
• view pour décrire les fonctions qui n’autorisent pas de modifications de l’état.
• payable pour décrire les fonctions qui peuvent recevoir de l’Ether.

Événements

Les événements décrivent des actions réalisées dans le contrat. Comme les fonctions, les événements ont des paramètres à spécifier quand ils sont appelés.

Pour appeler un événement, vous devez utiliser le mot clé emit avec le nom de l’événement et ses paramètres.

pragma solidity >0.7.0 <0.8.0;

contract Marketplace {
    event PurchasedItem(address buyer, uint price);

    function buy() public {
        // ...
        emit PurchasedItem(msg.sender, msg.value);
    }
}

Quand vous appelez un événement, celui-ci est capturé en tant que transaction dans le journal des transactions, qui est une structure de données spéciale dans la blockchain. Ces journaux sont associés à l’adresse du contrat et incorporés dans la blockchain. Ils y restent définitivement. Le journal et ses données d’événement ne sont pas accessibles à partir des contrats ni modifiables.

Continuer