Un guide pour commencer –

Solidity, un langage de programmation de contrats intelligents, est un mot à la mode depuis un certain temps. Ce tutoriel est destiné aux débutants prêts à explorer Solidity et à coder des contrats intelligents. Avant de commencer, nous allons clarifier les bases. Nous commencerons par explorer les contrats intelligents et leur efficacité, pour passer progressivement à la Solidité elle-même. Commençons!

Ce que vous apprendrez

À la fin de ce tutoriel, vous apprendrez

• Les bases des contrats intelligents
• Les bases de la Solidité
• Codage de base dans Solidité [19659005] Les applications de la solidité

Qu'est-ce que les contrats intelligents?

Le terme contrats intelligents a créé beaucoup d'exagération, et il reste encore à l'honneur juste après des termes comme intelligence artificielle, blockchain , Machine Learning, et ainsi de suite. Les contrats intelligents, ou contrats crypto, ne sont rien d'autre que des programmes informatiques auto-exécutables qui permettent des transactions numériques, des échanges commerciaux, des échanges de devises, des transferts d'actifs, etc. selon un ensemble de conditions prédéfinies appelé smart contract protocol . Les contrats intelligents veillent non seulement à ce que les deux parties respectent les règles et les conditions du contrat, mais aussi à ce que les obligations contractuelles soient automatiquement exécutées.

Comment fonctionnent les contrats intelligents?

Les contrats intelligents fonctionnent sur un réseau blockchain donné. Un contrat intelligent prend l'information comme une entrée, attribue une valeur à cette entrée en fonction des règles et des conditions du contrat codé, puis exécute ces actions conformément aux clauses. Par exemple, pendant un ICO, un contrat intelligent peut décider si le cryptocoin ira à l'acheteur ou au générateur de jetons.

Tous les contrats intelligents s'exécutent sur une couche blockchain, où toutes les données sont stockées avec des algorithmes Proof of Work ou Proof of Stake.

Smart contract applications

Les contrats intelligents sont des outils pratiques qui permettent le transfert d'actifs et l'exécution conditionnelle numériquement. Ils résolvent la question de la confiance mutuelle, de la transparence, de la communication mondiale et de l'économie. Voici quelques applications révolutionnaires dans le monde réel des contrats intelligents:

• L'exécution des transactions, y compris les processus juridiques
• L'exécution des transactions relatives à l'industrie de l'assurance
• L'exécution des accords de financement participatif et des campagnes ICO. ] L'exécution des transactions liées à la négociation, aux produits financiers dérivés, et à l'échange simple d'actifs et aux transferts.

Les contrats intelligents sont susceptibles de perturber les industries qui requièrent expertise et processus répétitifs – par exemple, les procédures légales. Ils ont également un potentiel pour les opérations d'audit en temps réel (qui prennent de nombreuses heures de travail si elles sont effectuées manuellement!) Et l'évaluation des risques, imposant ainsi le respect des normes établies

Les contrats intelligents peuvent-ils faire quelque chose? Cet outil unique de blockchain est tentant. Théoriquement, les contrats intelligents peuvent être utilisés pour résoudre des problèmes complexes de confiance, de transparence et d'exécution entre les parties contractantes tout en assurant la conformité et la gestion des risques. Cependant, la majorité des demandes de contrats intelligents sont simplement théoriques . Il y a des projets en cours de développement qui explorent des utilisations pour des contrats intelligents, mais la vérité est que nous avons trouvé des applications pratiques actuelles limitées.

Les contrats intelligents peuvent ne pas être en mesure de faire tout ce qu'ils promettent théoriquement, du moins actuellement. Voici les principales raisons:

Les contrats intelligents ne sont pas réellement «intelligents». Les contrats codés intelligents ne sont pas intrinsèquement intelligents ou intelligents. Ils sont appelés «intelligents» en raison de l'automatisation et de l'application des conditions qui y sont codées, et parce qu'il n'est pas nécessaire d'intervenir par une tierce partie. Mais en réalité, ils ne peuvent pas juger les circonstances et jouer selon le principe du «code est la loi». Bien que cela puisse être utile, cela peut aussi être dangereux. Par exemple, les conditions ne peuvent pas être modifiées ou altérées dans le contrat, même si les deux parties conviennent mutuellement d'une condition en dehors de l'accord. Les contrats intelligents exécutent simplement les conditions convenues mutuellement et suivent le code dans n'importe quel état.

Créer des contrats intelligents est très compliqué et fastidieux. Une autre raison pour laquelle les applications pratiques pour les contrats intelligents sont rares est l'ingénierie sophistiquée impliquée dans leur codage. Les contrats intelligents sont censés être Turing complet c'est-à-dire que le contrat intelligent peut simuler n'importe quelle machine de Turing. Pour cela, il doit être très compliqué, ce qui les rend difficiles à analyser. La prise est la sécurité. Si un contrat intelligent a des bogues, il peut être violé et il est inutile de l'utiliser. Analyser un contrat intelligent Turing-complete devient une tâche herculéenne. Même les contrats ordinaires nécessitent des années d'expertise et des constructions et des correctifs cohérents pour répondre aux besoins des utilisateurs.

Solidité

Solidité est un langage assez simple créé délibérément pour une approche simpliste des solutions réelles. Gavin Wood l'a initialement proposé en août 2014. Plusieurs développeurs de la chaîne Ethereum tels que Christian Reitwiessner, Alex Beregszaszi, Liana Husikyan, Yoichi Hirai et bien d'autres ont contribué à créer la langue. Le langage Solidity peut être exécuté sur la plate-forme Ethereum, c'est-à-dire une machine virtuelle primaire implémentant le réseau blockchain pour développer des registres publics décentralisés afin de créer des systèmes contractuels intelligents.

Le langage a les mêmes fonctionnalités que C et JavaScript. En outre, le langage prend en charge les variables d'état (similaires aux objets dans la programmation orientée objet), les types de données et les fonctions de programmation. Cependant, le langage fait face à des mises à niveau cohérentes et à des changements rapides sur toute la plateforme. Par conséquent, en tant que programmeur, vous devez faire attention aux mises à jour via les forums, les blogs et les forums de discussion de la plateforme Ethereum.

Solidity et Ethereum sont en développement proactif.

Comment apprendre la Solidité?

La symétrie syntaxique de Solidity avec ECMAScript (JavaScript) a considérablement amélioré la facilité d'utilisation du système. La documentation de conception d'Ethereum fait ressortir le modèle de pile et de mémoire avec une taille de mot d'instruction de 32 octets. Cette machine virtuelle Ethereum crée la pile de programme qui garde la trace des registres de compteur de programme et de stockage de données. Le compteur de programme boucle ou saute pour maintenir un flux séquentiel pour contrôler le programme.

La mémoire virtuelle donne également de la mémoire temporaire pour l'allocation de données qui est quelque peu extensible, comparée à l'allocation de stockage permanente apportée par les nœuds de la blockchain. Le langage est créé pour apporter de la précision et du déterminisme aux contrats intelligents. Pour "extraire" un bloc sur Ethereum, le noeud exécute des contrats intelligents et des méthodes de programmation dans les blocs correspondants.

Cela signifie que le code en cours d'exécution est planifié en fonction du flux de blocs. La nouvelle étape de l'exécution change la phase du programme en nouveaux espaces de stockage ou transactions. Ces transactions sont initialement effectuées sur le site du mineur. Une fois exécuté, le nouveau bloc est ensuite propagé aux autres noeuds actifs de la blockchain

Pour vérifier l'authenticité du système de contrat intelligent, chaque noeud vérifie indépendamment le bloc en comparant les changements d'état avec la copie locale disponible du bloc. Si les changements d'état sont déterministes, les transactions sont approuvées par les nœuds participants de la blockchain. Par conséquent, dans une situation où les nœuds ne pourraient pas arriver à un consensus, l'exécution du bloc s'arrête et le réseau peut s'arrêter.

Pour l'exécution continue de contrats intelligents sur un réseau blockchain, le contrat doit être déterministe, les nœuds vérifient continuellement les conditions à remplir pour le contrat intelligent

Solidity Basics

Pour commencer avec le langage et apprendre les bases, plongons dans le codage. Nous commencerons par comprendre la syntaxe et les types de données généraux, ainsi que les types de données variables. Solidité prend en charge les types de valeur génériques, à savoir:

Booleans : Renvoie la valeur comme vraie ou fausse. Les opérateurs logiques renvoyant des types de données booléens sont les suivants:

• ! Négation logique
• && conjonction logique, "et"
• || disjonction logique, "ou"
• == égalité
• ! = inégalité

Entiers : Supports de solidité int / unité pour les entiers signés et non signés respectivement. Ces allocations de stockage peuvent être de différentes tailles. Des mots-clés tels que uint8 et uint256 peuvent être utilisés pour allouer respectivement une taille de stockage de 8 bits à 256 bits. Par défaut, l'allocation est de 256 bits. Autrement dit, uint et int peuvent être utilisés à la place de uint256 et int256 . Les opérateurs compatibles avec les types de données entiers sont:

• Comparaisons: <= < == ! = > = > . Ils sont utilisés pour évaluer bool .
• Opérateurs de bits: & | ^ exclusif au niveau du bit 'ou', ~ négation des bits, "non".
• Opérateurs arithmétiques: + - unaire - unaire + * / % lieu, ** exponentiation, << virage à gauche, >> virage à droite

L'EVM renvoie une exception d'exécution lorsque l'opérateur de module est appliqué au zéro d'une opération de "division par zéro".

Adresse : Une adresse peut contenir une valeur de 20 octets équivalente à la taille d'une adresse Ethereum. Ces types d'adresse sont sauvegardés avec des membres qui servent de base de contrat

Littéraux de chaînes : Les chaînes littérales peuvent être représentées à l'aide de guillemets simples ou doubles (par exemple, "foo" ou «barre» ). Contrairement au langage C, les littéraux de chaîne dans Solidité impliquent des zéros de valeur de fin. Par exemple, "bar" représentera un élément de trois octets au lieu de quatre. De même, dans le cas des littéraux entiers, les littéraux sont convertibles de manière inhérente en utilisant l'ajustement correspondant, c'est-à-dire, octet ou chaîne.

Modifier : Dans un contrat intelligent, les modificateurs sont utilisés pour assurer la cohérence les conditions définies avant l'exécution du code.

Solidité fournit des tableaux de base, des énumérateurs, des opérateurs et des valeurs de hachage pour créer une structure de données appelée «mappages». Ces mappages sont utilisés pour renvoyer des valeurs associées à un emplacement de stockage donné. Un Array est une allocation mémoire contiguë d'une taille définie par le programmeur où si la taille est initialisée en K, et le type d'élément est instancié en T, le tableau peut s'écrire T [19659052]

Les tableaux peuvent également être dynamiquement instanciés en utilisant la notation uint [][6]. Ici, la notation initialise un tableau dynamique avec six allocations de mémoire contiguës. De même, un tableau bidimensionnel peut être initialisé comme arr [2][4]où les deux indices pointent vers les dimensions de la matrice

Nous commencerons notre entreprise de programmation par une structure simple de contrat. Considérons le code suivant:

 pragma solidity ^ 0.4.0;
contrat StorageBasic {
  uint storedValue;
  jeu de fonctions (uint var) {
     storedValue = var;
  }
  La fonction get () retourne la constante (uint) {
   return storedValue;
  }
}

Dans le programme ci-dessus, la première ligne du code déclare le code source à écrire dans la version 0.4.0 de Solidity. Le code sera donc compatible avec le EVM correspondant ou toute autre version supérieure

Une telle déclaration est essentielle pour s'assurer que le programme s'exécute comme prévu avec toutes les versions compatibles du compilateur. Le mot "Pragma" fait référence aux instructions données à un compilateur pour exécuter séquentiellement le code source.

La solidité est un langage typé statiquement. Par conséquent, chaque type de variable, quelle que soit sa portée, peut être instancié au moment de la compilation. Ces types élémentaires peuvent être combinés pour créer des types de données complexes. Ces types de données complexes se synchronisent ensuite les uns avec les autres en fonction de leurs préférences respectives.

Compiler et tester notre contrat intelligent

Pour tester votre contrat intelligent sur un système local, vous devez installer un environnement de test facile à utiliser. accepter les commandes simples Truffle. Vous pouvez utiliser l'Ethereum TestRPC pour cela. Il s'agit essentiellement d'un code mince qui crée un «faux» noeud sur le site de l'utilisateur et compile votre code Solidity à l'aide d'un port 8545. Le compilateur convertit le code source en code EVM, ce qui vous permet de tester votre code sans avoir à dépenser vos pièces Ether. Voici quelques commandes d'installation rapide:

 npm i -g ethereum-testrpc
testrpc -m "Ceci est un exemple de vérification du code"

Pour lancer la commande de compilation dans Truffle, nous utilisons la commande suivante:

 compilation de truffes

Une fois le code source compilé avec succès, la console retourne un message "Sauvegarde des artefacts". Sinon, il renvoie les erreurs de compilation pour votre code.

Une fois que vous connaissez l'idée des contrats intelligents, allez-y et apprenez les conceptions DApp sur le réseau Ethereum.

Les contrats intelligents ont créé un nouveau monde d'opportunités pour les entreprises en ligne et les innovations de blockchain. La technologie a donné naissance à Blockchain 2.0 en créant un registre décentralisé pour vérifier et faciliter les négociations numériques et développer un contrat. La solidité est le langage qui construira les systèmes contractuels à leur véritable potentiel et au-delà.

En tant que débutant, cet article vous donne un aperçu des règles de programmation impliquées dans le langage et de la façon dont vous pouvez utiliser ces bases pour créer vos propres systèmes de contrats intelligents.

Anthony Bergs est spécialiste du marketing numérique et gestionnaire de projets chez Writers Per Hour. Il garde toujours un oeil sur le secteur du marketing pour mettre en œuvre les meilleures innovations dans les stratégies qu'il construit. Il est toujours ouvert pour de nouvelles connexions et de nouveaux partenariats.