Commencez avec votre premier contrat intelligent – Meilleure programmation

Si vous connaissez les langages de programmation orientés objet, pensez à un contrat intelligent Solidity en tant que classe.

Comme toute autre langue, Solidity propose une gamme de types de données, notamment:

• Booléens
• Entiers
• Cordes
• Adresses
• Numéros à virgule fixe
• Tableaux

Il existe des modificateurs d’accès qui définissent qui et quoi peut accéder aux variables et aux fonctions:

• Publique
• Privé
• Interne
• Externe

Un contrat intelligent peut avoir des variables d’état et locales, un constructeur et des fonctions.

Fondamentalement, Solidity permet à tout contrat d’accéder aux informations de la chaîne de blocs (comme la quantité d’ETH d’une adresse particulière) en utilisant des variables disponibles à l’échelle mondiale. Celles-ci sont essentielles pour effectuer des opérations sécurisées basées sur des règles comme l’envoi d’ETH à d’autres adresses.

Donc, si un contrat intelligent est un portefeuille avec des règles, utilisons-le comme exemple. Faisons un contrat portefeuille simple qui peut contenir, envoyer et recevoir des ETH.

Allons de haut en bas, puis vérifions que nous remplissons tous les critères que nous avons définis pour notre portefeuille.

Définir la version Solidity

Définissez la version du compilateur de solidité avec pragma solidity …. Nous utilisons 0.6.0 ici.

Définir le nom du contrat

Variable d’état du propriétaire

Nous devons savoir à qui appartient ce portefeuille. Il est stocké dans une variable d’état appelée owner, que nous définissons à l’intérieur du contrat mais en dehors de toute fonction. Cela signifie que toutes les fonctions ont accès à la valeur stockée dans cette variable.

Il a private visibilité, ce qui signifie que seules les fonctions de ce contrat peuvent y accéder. Et il stocke address payable saisir des données. payable signifie que ce contrat peut lui envoyer de l’éther.

Le constructeur

constructor() est exécuté lorsque le contrat est créé sur la blockchain. La seule ligne à l’intérieur de cette fonction est de stocker l’adresse du déployeur. Nous savons déjà que chaque contrat intelligent a une adresse, mais ils doivent être déployés à l’aide d’une adresse existante.

C’est là que nous voyons la première utilisation d’une variable disponible à l’échelle mondiale. msg.sender représente l’adresse du déployeur (la personne / le portefeuille / le contrat intelligent qui a exécuté cette fonction).

Toute adresse peut déployer un contrat intelligent ou appeler n’importe quelle fonction d’un contrat intelligent, qu’il s’agisse d’un portefeuille contrôlé par l’homme ou d’un autre contrat intelligent.

À ce stade, deux adresses sont en jeu: l’adresse du déployeur (msg.sender) et l’adresse à laquelle ce contrat a été déployé (plus à ce sujet au fur et à mesure que nous progressons dans le code).

Recevoir de l’éther

Pour que ce contrat puisse recevoir des ETH à partir des adresses qui lui sont envoyées, il lui faut un receive() une fonction. Il s’agit d’une fonction spéciale définie dans Solidity que tout contrat souhaitant recevoir des ETH doit mettre en œuvre. Il doit avoir le modificateur d’accès external afin que les adresses extérieures puissent y accéder, et il doit être payable, ce qui signifie qu’il peut recevoir des ETH (tout comme notre propriétaire peut recevoir des ETH et est donc également payable).

Envoyer de l’éther

La dernière fonction est appelée sendEther(). C’est ce qui facilite l’envoi par le propriétaire d’ETH de ce contrat portefeuille à une autre adresse. Il faut deux paramètres: l’adresse à laquelle envoyer l’ETH et le montant à envoyer.

Remarquez qu’il y a deux require au début de cette fonction. Cela garantit que certains critères sont remplis avant que la fonction puisse continuer. Si une exigence échoue, la transaction est complètement annulée.

La première exigence:

Cela garantit que l’adresse qui a appelé cette fonction est le propriétaire du portefeuille. Nous ne voulons pas qu’une personne qui n’est pas propriétaire puisse envoyer de l’ETH à quelqu’un. Seul le propriétaire devrait pouvoir le faire.

La deuxième exigence:

Cela garantit que le contrat de portefeuille a suffisamment d’ETH à envoyer. Il ne peut pas transférer plus qu’il ne possède.

Ceci est un autre exemple d’utilisation de variables accessibles à l’échelle mondiale pour interroger la quantité d’ETH de ce contrat. address(this) obtient l’adresse à laquelle ce contrat intelligent est déployé, puis .balance renvoie la quantité d’ETH que possède l’adresse. Tant qu’il est supérieur ou égal au montant que la fonction souhaite envoyer (_amount), alors nous pouvons continuer!

Enfin, la fonction envoie l’ETH à l’adresse cible en utilisant _to.transfer(_amount);.