Ethereum

Ethereum

• Lancé en 2015, Ethereum s’appuie sur l’innovation portée par le Bitcoin.

• Plateforme Blockchain décentralisée qui établit un réseau peer to peer qui exécute et vérifie en
toute sécurité le code d’application, appelé smart contract.
• Les smart contract permettent aux participants d’effectuer des transactions entre eux sans autorité
centrale de confiance.
 Origine et lancement

• Le programmeur Vitalik Buterin découvre les cryptomonnaies avec le Bitcoin en 2011 et décide de
créer un nouveau protocole utilisant un langage Turing complet plutôt d’alourdir la structure du
Bitcoin, l’idée d’ethereum naissait.
 Présentation de Ethereum

• Ethereum est un accès ouvert à la monnaie numérique et à des services conviviaux pour tout le
monde, qui que vous soyez.
• C’est une technologie construite par la communauté derrière la cryptomonnaie ether (ETH) et des
milliers d’applications que vous pouvez utiliser dès aujourd’hui.
 Ethereum promet ces postulats

• Un internet plus respectueux de la vie privée;

• Un réseau P2P;
• Résistant à la censure;
• Garanties de commerce;
• La compatibilité avant tout.
 Un internet plus respectueux de nos données personnelles

• Il n’est pas nécessaire de fournir l’ensemble de nos informations d’identité pour utiliser une
application Ethereum.

• Ethereum construit une économie basée sur la valeur, pas sur la surveillance.
 Un réseau peer to peer

• Il ne permet pas de déplacer de l’argent, ou de conclure des accords, directement avec une autre
personne.

• Il n’est plus nécessaire de passer par des entreprises intermédiaires.

 Résistant à la censure

• Aucun gouvernement ou entreprise ne peut contrôler Ethereum.

• La décentralisation rend impossible le blocage de paiements ou l’utilisation des services sur

Ethereum.
 Transactions commerciales sécurisées

• Les parties ont la garantie que les fonds changeront de main que si les règles de la transaction
commerciale sont respectées.
 Applications modulables

• Comme les applications sont construites sur la même blockchain, elles peuvent s’emboiter les unes
sur les autres (comme des legos).
 Ether, la cryptmonnaie d’Ethereum

• Ethereum possède une cryptomonnaie native appelée ether (ETH).

• Les nouveaux tokens sont émis aux validateurs qui sécurisent le réseau Ethereum.

• Chaque action sur le réseau Ethereum nécessite une certaine quantité de puissance de calcul.

• Frais payés avec des ETH.

 Le cas d’usage des ETH

• La DeFi ouvre des domaines entiers de services bancaires à toute personne disposant d’une connexion
internet.
• DeFi, (ou « decentralized finance » (finance décentralisée), est un terme générique désignant les services
financiers sur les blockchains publiques, principalement l'Ethereum. La DeFi vous offre des services
bancaires classiques (percevoir des intérêts, emprunter, prêter, acheter des assurances, négocier des
produits dérivés et des actifs, et bien plus encore) mais avec plus de rapidité, sans paperasse et sans
intermédiaire. À l'image de la plupart des cryptomonnaies, la DeFi est internationale, de pair à pair (P2P)
(elle intervient directement entre deux personnes sans être acheminée via un système centralisé), anonyme
et ouverte à tous.

• Elle propose certaines alternatives à ce que fait la finance centralisée.

• Ethereum est le cœur de la DeFI avec des cas d’utilisation comprenant des stablecoins, des prêts, des
emprunts et de la gestion d’actifs.
 Le standard ERC-20

• Création de nouvelles cryptomonnaies appelées tokens.

• ERC-20 définit les règles à respecter pour la création d’un nouveau token.
• Comportement des tokens normalisé.
• ISO lancées sur l’écosystème Ethereum.
• Un token, en revanche, est une représentation numérique d'un actif ou d'une valeur spécifique qui
est émis et fonctionne sur une blockchain existante. Les tokens ne sont pas autonomes et
dépendent de la blockchain sur laquelle ils sont construits, telle que la blockchain Ethereum. Les
tokens sont généralement créés à l'aide de contrats intelligents et suivent des normes spécifiques,
comme le standard ERC-20 pour les tokens sur Ethereum.
 Qui gère Ethereum?

• Ethereum n’est contrôlé par aucune entité.

• Existe grâce à la participation et à la coopération décentralisée de la communauté Ethereum.

• Ces nœuds distribués offrent une résilience à l’infrastructure du réseau Ethereum qui de fait est
beaucoup moins vulnérable aux piratages ou aux arrêts.

• Depuis son lancement en 2015, Ethereum n’a jamais subi d’interruption.

• Ethereum est l’une des cryptomonnaies les plus décentralisées après le Bitcoin.
Les smart-contracts
Les smart-contracts
 Les smart-contracts

• Les contrats intelligents (en anglais : smart contracts) sont des protocoles informatiques qui
facilitent, vérifient et exécutent la négociation ou l'exécution d'un contrat, ou qui rendent une
clause contractuelle inutile (car rattachée au contrat intelligent). Les contrats intelligents ont
généralement une interface utilisateur et émulent la logique des clauses contractuelles. Cependant,
les contrats intelligents sont du code informatique, et si l'interface utilisateur venait à disparaître, il
serait toujours possible d'interagir avec ceux-ci. Seul un arrêt du réseau sur lequel les contrats
intelligents sont hébergés pourrait mener à son inaccessibilité.
 Qu’en est-il de la consommation d’énergie d’Ethereum?

• Le 15 septembre 2022, mise à jour importante appelée ’the merge’.

• Proof of work remplacé par proof of stake (preuve d’enjeu).

• The merge a réduit de 99,95% la consommation d’énergie nécessaire pour sécuriser Ethereum, créant ainsi un réseau plus sur
pur un cout carbone plus faible.
 Le staking

• Faire du staking, c’est devenir validateur de nœuds en déposant 32 Eth.

• Validateur sécurise la blockchain d’Ethereum.
 Conservation des données;
 Traitement des transactions;
 Ajout de nouveaux blocs à la blockchain.

• Des récompenses sont attribuées aux validateurs.

• Le réseau devient plus fort contre les attaques grâce aux Eth qui sont stakés et qui permettent de contrôler le
réseau Eth.

• Contrairement au Bitcoin, staker ne nécessite pas des calculs intensifs en énergie de type proof of work. Les
nœuds de proof of stake peuvent fonctionner sur des matériels modestes et en utilisant moins d’énergie.
Le gaz en Ethereum
• Lorsque vous effectuez une transaction ou exécutez un contrat intelligent sur la blockchain Ethereum, vous
devez payer des frais de gaz pour couvrir les coûts de calcul et de stockage nécessaires à l'exécution de
cette action. Ces frais de gaz sont généralement exprimés en "Gwei", une subdivision de l'Ether (ETH), la
crypto-monnaie native d'Ethereum.

• Le montant de gaz requis pour une transaction ou une opération dépend de sa complexité et de la charge du
réseau Ethereum à ce moment-là. Plus une transaction est complexe et nécessite de ressources réseau, plus
elle nécessitera de gaz et donc de frais.
• Les frais de gaz servent également à inciter les mineurs à inclure votre transaction dans un bloc de la
blockchain. Les mineurs choisissent généralement les transactions avec les frais de gaz les plus élevés, car
ils sont récompensés en ETH pour leur travail de validation des transactions.
EVM: Ethereum Virtual Machine
• L'EVM (Ethereum Virtual Machine) est une composante essentielle de la blockchain Ethereum. Il s'agit
d'une machine virtuelle qui exécute les contrats intelligents et les transactions sur le réseau Ethereum.

• L'EVM est un environnement d'exécution isolé et sécurisé dans lequel les contrats intelligents sont
exécutés. Il fournit un cadre pour l'exécution de codes sur la blockchain Ethereum en utilisant le langage
de programmation Solidity, principalement utilisé pour écrire des contrats intelligents sur Ethereum.

• L'EVM est responsable de la validation et de l'exécution des transactions, ainsi que du calcul des frais de
gaz associés. Chaque instruction exécutée sur l'EVM nécessite un certain montant de gaz, qui est payé par
l'utilisateur. Les mineurs qui valident les transactions sont récompensés en fonction des frais de gaz
collectés.
• L'EVM est responsable de la validation et de l'exécution des transactions, ainsi que du calcul des
frais de gaz associés. Chaque instruction exécutée sur l'EVM nécessite un certain montant de gaz,
qui est payé par l'utilisateur. Les mineurs qui valident les transactions sont récompensés en
fonction des frais de gaz collectés.
Premier smart contract avec solidity
• // SPDX-License-Identifier: MIT
• pragma solidity ^0.8.0;

• contract GetSet {
• uint private var;

• function getVar() public view returns (uint) {

• return var;
• }

• function setVar(uint Nval) public {

• var= Nval;
• }
• }
• https://remix.ethereum.org/
Metamask
• MetaMask est un portefeuille logiciel de crypto-monnaie utilisé pour interagir avec la blockchain
Ethereum. Il permet aux utilisateurs d'accéder à leur portefeuille Ethereum via une extension de
navigateur ou une application mobile, qui peut ensuite être utilisée pour interagir avec des
applications décentralisées. MetaMask est développé par ConsenSys Software Inc., une société de
logiciels blockchain développant des outils dans l'univers d'Ethereum.
• MetaMask permet aux utilisateurs de stocker et de gérer les clés de leurs comptes, de diffuser des
transactions, d'envoyer et de recevoir des crypto-monnaies et des jetons basés sur Ethereum et
de se connecter de manière sécurisée à des applications décentralisées via un navigateur Web
compatible ou le navigateur intégré de l'application mobile.
• Les sites Web ou autres applications décentralisées peuvent se connecter, authentifier et intégrer
d'autres fonctionnalités de contrat intelligent avec le portefeuille MetaMask d'un utilisateur (et
toute autre extension de navigateur de portefeuille blockchain similaire) via un code JavaScript
permettant au site Web d'envoyer des invites d'action, des demandes de signature, ou des
demandes de transaction à l'utilisateur via MetaMask en tant qu'intermédiaire
Alimenter votre wallet metamask
• https://sepoliafaucet.com/
Langage Solidity
Le langage solidity
• Contrats
• Commençons par les bases :
• Un contrat (contract) permet d'encapsuler du code Solidity, c'est la composante fondamentale de
toutes applications Ethereum - toutes les variables et fonctions appartiennent à un contrat, et ce
sera le point de départ de tous vos projets.
• Un contrat vide nommé Contrat1 ressemblerait à ceci :
contract contrat1 {

}
Le langage solidity
• Le commentaire // SPDX-License-Identifier: MIT est une indication spécifique placée en haut du
fichier source d'un contrat intelligent (smart contract) en Solidity. Ce commentaire est utilisé pour
spécifier la licence sous laquelle le contrat intelligent est publié. Il suit la spécification SPDX
(Software Package Data Exchange), qui fournit un format standard pour déclarer des informations
de licence dans le code source d'un logiciel.

• Pragma version
• Tout code source en Solidity doit commencer par un "pragma version" - une déclaration de la
version du compilateur Solidity que ce code devra utiliser. Cela permet d'éviter d'éventuels
problèmes liés aux changements introduits par des futures versions du compilateur.
• Cela ressemble à ça : pragma solidity ^0.8.0;
Le langage solidity
• Variables d'état et entiers
• Maintenant que nous avons une structure pour notre contrat, voyons voir comment Solidity gère
les variables.
• Les variables d'état sont stockées de manière permanente dans le stockage du contrat. Cela signifie
qu'elles sont écrites dans la blockchain Ethereum. C'est comme écrire dans une base de données.
• contract Example {
• // Cela sera stocké de manière permanente dans la blockchain.
• uint myUnsignedInteger = 100;
• }
• Dans cet exemple de contrat, nous avons créé un uint appelé myUnsignedInteger qui a pour valeur
100.
Le langage solidity
• Variables d'état et entiers
• Entiers non signés : uint
• Le type de données uint est un entier non signé, cela veut dire que sa valeur doit être non négative.
Il existe aussi un type de données int pour les entiers signés.
• Remarque: En Solidity, uint est en fait un alias pour uint256, un entier non signé de 256 bits. Vous
pouvez déclarer des uints avec moins de bits - uint8, uint16, uint32, etc. Mais en général il est plus
simple d'utiliser uint sauf dans des cas spécifiques1
• String, bool, address
Le langage solidity
• Opérations Mathématiques
• Les opérations Mathématiques en Solidity sont assez simples. Les opérations sont les
mêmes dans la plupart des langages de programmation
• Addition : x + y
• Soustraction : x - y
• Multiplication : x * y
• Division : x / y
• Modulo / reste : x % y (par exemple, 13 % 5 est 3, car si vous divisez 13 par 5, le reste est
3)
• Solidity prend aussi en charge l'opérateur exponentiel (c.-à-d. "x à la puissance y", x^y) :
• uint x = 5 ** 2; // égal à 5^2 = 25
Le langage solidity
• Structures de contrôle
• La plupart des structures de contrôle connues des langages à accolades sont disponibles dans
Solidity :
• Il y a : » if « , » else « , « while « , » do « , » for « , » break « , » continue « , » return « , avec la
sémantique la sémantique habituelle connue en C ou en JavaScript.

• Les fonctions pratiques ``assert”” et ``require”” peuvent être utilisées pour vérifier les conditions
et lancer une exception si la condition n’est pas remplie.
Le langage solidity
• Constructeur
• En Solidity, le constructeur est une fonction spéciale d'un contrat intelligent (smart contract) qui est exécutée une seule fois lors du
déploiement du contrat sur la blockchain. Le constructeur est utilisé pour effectuer des initialisations de contrats, telles que l'attribution de
valeurs initiales à des variables d'état ou l'exécution de certaines logiques nécessaires lors de la création du contrat.
• // SPDX-License-Identifier: MIT
• pragma solidity ^0.8.0;

• contract MonContrat {
• // Variable d'état
• uint public maVariable;

• // Constructeur
• constructor() {
• // Initialisation de la variable d'état
• maVariable = 42;
• }

• }
Le langage solidity
• Structures
• Il est possible que vous ayez besoin d'un type de données plus complexe. Pour cela, Solidity
fournit les structures (struct) :
• struct Personne {
• uint age;
• string nom
• }
• Les structures vous permettent de créer des types de données plus complexes avec plusieurs
propriétés.
• Remarque : Nous venons d'introduire un nouveau type, string (Chaîne de caractères). Les chaînes
de caractères sont utilisées pour les données UTF-8 de longueur arbitraire. Ex. string greeting =
"Hello world!"
Le langage solidity
• Tableaux
• Quand vous voulez regrouper des éléments, vous pouvez utiliser un tableau (array). il y a deux sortes
de tableaux dans Solidity : les tableaux fixes et les tableaux dynamiques :
• // Tableau avec une longueur fixe de 2 éléments :
• uint[2] fixedArray;
• // Un autre Tableau fixe, qui peut contenir 5 `string` :
• string[5] stringArray;
• // un Tableau dynamique, il n'a pas de taille fixe, il peut continuer de grandir :
• uint[] dynamicArray;
• Vous pouvez aussi créer un tableau de structure. En utilisant la structure Person du chapitre précédent :
Personne[] people; // Tableau dynamique, on peut en rajouter sans limite.
• Vous vous rappelez que les variables d'état sont stockées définitivement dans la blockchain ? Il peut
donc être utile de créer des tableaux dynamiques de structure pour stocker des données structurées
dans votre contrat, un peu comme une base de données.
Le langage solidity
• Tableaux publics
• Vous pouvez déclarer un tableau comme public, et Solidity créera automatiquement une méthode
d'accès. La syntaxe ressemble à :
• uint[] public people;
• Les autres contrats vont pouvoir lire (mais pas écrire) ce tableau. C'est donc une façon utile pour
stocker des données publiques dans votre contrat.
Le langage solidity
• Déclarations de fonction
• Une déclaration de fonction (function) en Solidity ressemble à ça:
• function ajout(string _name, uint _amount) {
• }
• C'est une fonction appelée ajout qui prend 2 paramètres : un string et un uint. Le corps de la
fonction est vide pour l'instant.
• Remarque: Par convention (mais ce n'est pas obligatoire), les noms des paramètres des fonctions
commencent avec un trait de soulignement (_) afin de les différencier des variables globales
• Vous pouvez appeler la fonction comme cela :

• ajout("ahmed", 100);
Le langage solidity
• Manipuler des structures et des tableaux
• Créer de nouvelles structures
• Vous vous rappelez de notre structure Personne dans l'exemple précédent ?
struct Personne {
uint age;
string name;
}
• Personne[] public people;
Le langage solidity
• Manipuler des structures et des tableaux
• Nous allons maintenant apprendre comment créer des nouvelles Person et les ajouter à notre tableau people.
• // créer une nouvelle Person :
• Personne satoshi = Personne(172, "Satoshi");

• // L'ajouter au tableau :
• people.push(satoshi);
• Vous remarquerez que array.push() ajoute quelque chose à la fin du tableau, les éléments sont donc rangés selon
l'ordre d'ajout. Exemple :
• uint[] numbers;
• numbers.push(5);
• numbers.push(10);
• numbers.push(15);
• // numbers est maintenant égal à [5, 10, 15]
Le langage solidity
• Fonctions privées / publiques
• En Solidity, les fonctions sont publiques par défaut. Cela signifie que n'importe qui (ou n'importe
quel contrat) peut appeler la fonction de votre contrat et exécuter son code.

• Évidemment, ce n'est pas toujours ce que l'on veut, cela pourrait rendre votre contrat vulnérable
aux attaques. Il est donc recommandé de marquer vos fonctions comme private (privées) par
défaut, puis de ne rendre public (publiques) seulement les fonctions que vous voulez exposer à
tout le monde.
• Voici comment déclarer une fonction privée :
uint[] numbers;
function _addToArray(uint _number) private {
numbers.push(_number);
}
Le langage solidity
• Fonctions privées / publiques
• Cela veut dire que seulement les autres fonctions de notre contrat pourront appeler cette fonction
et ajouter quelque chose au tableau array.
• Comme vous pouvez le voir, nous avons utilisé le mot-clé private après le nom de la fonction. Et
comme les arguments d'une fonction, par convention les fonctions privées commencent par un trait
de soulignement (_).
Le langage solidity
• Plus sur les fonctions
• Dans ce chapitre, nous allons apprendre les valeurs retournées des fonctions, ainsi que les
modificateurs de fonction.
• Valeurs retournées
• Pour retourner une valeur à partir d'une fonction, cela ressemble à ça :
string greeting = "ceci est un smart contract";

function sayHello() public returns (string) {

return greeting;
}
En Solidity, une déclaration de fonction indique le type de la valeur retournée (dans ce cas string).
Le langage solidity
• Plus sur les fonctions
• Modificateurs de fonction
• La fonction ci-dessus ne change pas un état en Solidity - c.-à-d. elle ne change pas une valeur et
n'écrit rien.

• Dans ce cas là, nous pouvons la déclarer comme une fonction view (vue), cela veut dire qu'elle va
seulement voir des données sans les modifier :
• function sayHello() public view returns (string) {
Le langage solidity
• Fonction payable
• Une fonction payable dans Solidity est une fonction qui peut recevoir des ethers (la cryptomonnaie
native d'Ethereum) lorsqu'elle est appelée. Cela permet à un contrat d'accepter des fonds,
généralement utilisés pour des opérations telles que des enchères, des paiements, ou d'autres
mécanismes financiers.