Dans cette section, nous discuterons du processus d'écriture d'un contrat intelligent de base en utilisant Solidity. Nous couvrirons des composants essentiels tels que les variables, les fonctions et les modificateurs. Ensuite, nous passerons en revue un exemple d'implémentation d'un contrat de jeton simple.

Variables, fonctions et modificateurs

• VariablesEn Solidity, il existe deux types de variables - les variables d'état et les variables locales. Les variables d'état sont stockées de manière permanente sur la blockchain, tandis que les variables locales sont temporaires et n'existent que dans le cadre d'une fonction.

• Fonctions: Les fonctions sont les blocs de construction des contrats intelligents. Elles sont utilisées pour accomplir des tâches spécifiques, telles que la création de transactions et l'exécution de logiques personnalisées. Les fonctions peuvent avoir des paramètres d'entrée et des valeurs de retour, permettant une plus grande personnalisation et flexibilité.

• Modificateurs: Les modificateurs sont propres à Solidity et sont utilisés pour modifier le comportement d'une fonction. Ils peuvent améliorer la lisibilité et la gestion du code et peuvent être utilisés pour authentifier les valeurs entrantes ou exécuter conditionnellement une fonction appelée.

Exemple1: Mise en œuvre d'un contrat de jeton simple

Créons un contrat de jeton simple en utilisant Solidity. Ce contrat permettra aux utilisateurs de transférer des jetons entre des comptes et de vérifier le solde de jetons de n'importe quel compte.

TypeScriptpragma solidité ^0.8.0;contrat SimpleToken {    // Déclarer les variables d'état    adresse publique propriétaire;    mappage(adresse => uint256) soldes publics;    // Initialiser le contrat de jeton    constructeur(uint256 offreInitiale) {        propriétaire = msg.sender;        soldes[propriétaire] = offreInitiale;    }    // Fonction de transfert de jetons    fonction transférer(adresse à, uint256 montant) public {        requiert(soldes[msg.sender] >= montant, "Solde insuffisant");        soldes[msg.sender] -= montant;        soldes[à] += montant;    }    // Fonction pour vérifier le solde du jeton d'un compte    fonction balanceOf(adresse compte) public vue retourne (uint256) {        retourne soldes[compte];    }}

Dans ce contrat, nous avons :

• Variables d'étatpropriétaireetsoldespour stocker respectivement l'adresse du propriétaire du contrat et les soldes de jetons de toutes les adresses.

• Une constructeurfonction qui définit l'approvisionnement initial de jetons et les attribue au propriétaire du contrat.

• Un transfertfonction qui permet aux utilisateurs de transférer des jetons vers d'autres comptes. Elle utilise le exigerdéclaration pour s'assurer que l'expéditeur a suffisamment de jetons à transférer.

• Un soldeDefonction qui retourne le solde du jeton d'un compte spécifié.

• Ce contrat de jeton de base montre comment utiliser des variables, des fonctions et des modificateurs en Solidity pour créer un contrat intelligent simple et fonctionnel.

Exemple2: Mise en œuvre d'un système de vote simple

pragma solidity ^0.8.0;contrat SystèmeDeVote {    mapping (bytes32 => uint256) public votesReceived;    bytes32[] public listeDesCandidats;    constructor(bytes32[] memory nomsDesCandidats) {        listeDesCandidats = nomsDesCandidats;    }    function voterPourCandidat(bytes32 candidat) public {        require(candidatValide(candidat), "Candidat invalide.");        votesReceived[candidat] += 1;    }    function totalVotesPour(bytes32 candidat) public view returns (uint256) {        require(candidatValide(candidat), "Candidat invalide.");        return votesReceived[candidat];    }    function candidatValide(bytes32 candidat) public view returns (bool) {        for (uint256 i = 0; i < listeDesCandidats.length; i++) {            if (listeDesCandidats[i] == candidat) {                return true;            }        }        return false;    }}

Dans cet exemple, le Système de votele contrat permet aux utilisateurs de voter pour l'un des plusieurs candidats en appelant le voter pour un candidatfonction. Le contrat garde une trace du nombre de votes reçus pour chaque candidat à l'aide d'un votes reçusle mappage, où la clé est le nom du candidat et la valeur est le nombre de votes. Le Liste des candidatsvariable stocke la liste des candidats valides. totalVotesForla fonction peut être appelée pour vérifier le nombre de votes qu'un candidat spécifique a reçus, et le candidat validela fonction vérifie si un candidat est valide. Il s'agit d'un exemple simple de la façon dont Solidity peut être utilisé pour construire des applications décentralisées avec une logique complexe.

Points forts
Les variables, les fonctions et les modificateurs sont des composants essentiels des contrats intelligents Solidity.
Solidity a deux types de variables : les variables d'état et les variables locales.
Les fonctions sont utilisées pour effectuer des tâches et peuvent avoir des paramètres d'entrée et des valeurs de retour.
Les modificateurs sont utilisés pour modifier le comportement d'une fonction et améliorer la lisibilité et la gestion du code.
Le contrat SimpleToken permet aux utilisateurs de transférer des jetons et de vérifier les soldes des jetons.
Le contrat SimpleToken démontre l'utilisation de variables d'état, d'une fonction de constructeur et de fonctions comme transférer et balanceOf.
Le contrat VotingSystem permet aux utilisateurs de voter pour des candidats et de suivre les comptes de vote.
Le contrat VotingSystem montre l'utilisation de mappings, de tableaux et de fonctions comme voteForCandidate, totalVotesFor et validCandidate.