Smart Contract

Introduction
• Le contrat intelligent est la pièce maîtresse de la
blockchain Ethereum. C'est une fonctionnalité
puissante
• Une conception et un codage incorrects d'un contrat
intelligent ont entraîné des échecs importants tels
que le piratage de DAO et le verrouillage du
portefeuille de Parity.
• Le contrat intelligent est une expression surchargée. Bien
qu'il y ait différentes interprétations du contrat intelligent,
nous le définissons comme suit : " Un contrat intelligent est
un programme informatique qui s'exécute sur la machine
virtuelle Ethereum (EVM) sur la blockchain pour accéder et
modifier l'état des blocs". Contrairement aux programmes
informatiques conventionnels qui s'exécutent normalement
sur un seul système, les contrats intelligents fonctionnent sur
chaque nœud de la blockchain.
Pour Ethereum, les contrats intelligents sont compilés sous forme de
bytecode exécutable et déployés sur la blockchain Ethereum. Les bytecodes
d'un contrat intelligent sont envoyés dans le champ de données d'une
transaction. Une fois que la transaction est incluse dans un bloc, une
adresse du contrat intelligent est générée, le bytecode est stocké dans cette
adresse.

Pour appeler une fonction dans un contrat intelligent, une transaction est
envoyée à l'adresse du contrat intelligent, le nom de la fonction et les
données d'entrée sont fournis par le champ de données de la transaction.
Lorsqu'une transaction appelant un contrat intelligent est envoyée à un
nœud, la machine virtuelle Ethereum charge le bytecode de l'adresse du
contrat intelligent et exécute la fonction.
Pour un homme d'affaires, un smart contract définit des attributs
commerciaux et des traitements logiques afin de permettre à plusieurs
parties d'exécuter et d'être témoins du traitement de la logique métier afin
de garantir la transparence, la fiabilité, la tolérance aux pannes,
l'immuabilité et l'intégrité pour toutes les parties (lorsque le contrat
intelligent est bien rédigé).
Les contrats intelligents diffèrent des programmes informatiques autonomes
car ils sont présents sur toutes les machines et toutes les parties ont accès
afin de profiter de la transparence, de la fiabilité et d'autres avantages de la
blockchain, mais ce n'est le cas que lorsque le contrat intelligent est bien
écrit.
Si un contrat intelligent est mal écrit, tous ces avantages disparaissent.
Pour une personne technique, un contrat intelligent est un programme
informatique qui peut être codé, compilé, testé, déployé et exécuté sur une
blockchain.
D'un point de vue technique, l'expression "contrat intelligent" peut
signifier plusieurs choses :
Premièrement, elle peut signifier le code source du contrat intelligent.
Deuxièmement, elle peut signifier un bytecode compilé d'un contrat
intelligent.
Troisièmement, il peut s'agir d'un contrat intelligent déployé résidant sur
une blockchain.
Lorsqu'un smart contract est compilé, deux fichiers sont générés : un fichier
bytecode et un fichier ABI (Application Bytecode Interface).
Le bytecode d'un contrat intelligent peut être déployé sur la blockchain
Ethereum et peut être exécuté par la machine virtuelle Ethereum. Le code
ABI est une définition et une description du contrat intelligent plutôt qu'un
code exécutable.
Le fichier ABI est utilisé par des applications tierces pour analyser les
fonctions définies dans un contrat intelligent déployé et la façon d'interagir
avec elles.
Lorsqu'un contrat intelligent est "déployé" sur une blockchain, une adresse
de contrat intelligent est générée en calculant le hachage Keccak-256 de
l'adresse de l'expéditeur et du nonce de la transaction encodé avec un
préfixe de longueur récursive (RLP) sérialisation.
Un contrat intelligent peut également être déployé sur différentes
différentes blockchains, telles que testnet ou mainnet. La même adresse de
contrat intelligent peut faire référence à différentes blockchains.
Il est important de savoir que les " contrats intelligents " sont utilisés dans
différents scénarios et contextes.
Puisqu'un contrat intelligent est déployé dans la blockchain, il s'agit d'un
morceau de code immuable, une fois déployé, il ne peut pas être modifié.
Nous devrons redéployer le code en tant que nouveau contrat intelligent, ou
rediriger d'une manière ou d'une autre les appels d'un ancien contrat vers le
nouveau. Le contrat intelligent peut stocker des variables appelées variables
d'état. Nous pouvons récupérer comment ces variables changent au fil des
blocs. Le contrat dans la blockchain Ethereum a une directive pragma, le nom
du contrat, les données ou la variable d'état qui définissent l'état du contrat,
la collection de fonctions pour réaliser l'intention d'un contrat intelligent.
Nous allons utiliser un environnement de développement intégré (IDE)
appelé Remix pour créer, déployer, exécuter et explorer le fonctionnement
de quelques contrats intelligents. Il est disponible à Remix.ethereum.org.

Il existe 3 types d'environnements dans lesquels Remix peut être branché :

• Javascript VM
• Injected Web3
• Web3 Provider
Injected Web3 et Web3 Provider nécessitent tous deux l'utilisation d'un
outil externe.
L'outil externe pour Injected provider est Metamask.
Certains outils externes utilisés avec Web3 provider sont : Truffle,
Ganache-CLI, Hardhat node ou un nœud Ethereum lui-même.

La VM JavaScript est pratique car il s'agit d'une blockchain qui fonctionne

dans le navigateur sans avoir besoin d'un autre logiciel ou d'un nœud
Ethereum pour l'exécuter
Create Ethereum Smart Contract using Remix
//SPDX-License-Identifier: MIT
pragma solidity ^0.4.0;
contract Hello{
string public name;
string public message;
constructor(string newmess,string newname){
message=newmess;
name=newname;
}
function update(string chmess,string chname) public{
message=chmess;
name=chname;
}

}
pragma solidity ^0.4.0;

contract Greeter {
string public yourName; // data

/* This runs when the contract is executed */

function Greeter() public {
yourName = "World";
}
function set(string name)public {
yourName = name;
}
function hello() constant public returns (string) {
return yourName;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.9;
contract Greeter{
string public votrenom;
function Greeter (){
votrenom="world";
}
function set(string memory nvnom) public {
votrenom=nvnom;
}
function hello() constant returns (string)
{
return votrenom;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.7;
contract Storage{
uint public number;
constructor(uint nvnumber){
number=nvnumber;
}
function increment_number()public{
number=number+1;
}
function decrement_number()public{
number=number-1;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.4.7;
contract Storage{
uint public number;
function set (uint nvnumber) public{
number=nvnumber;
}
function get() constant public returns(uint){
return number;
}
function increment_number(uint n)public{
number=number+n;
}
function decrement_number(uint n)public{
number=number-n;
}

}
pragma solidity ^0.4.7;
contract firstcontract{
string public word="bonjour";
int public nombre1;
uint nombre2=200;
function get()constant public
returns(uint,string){
return (nombre2, word);
}
}
pragma solidity ^0.4.7;
Ajout de modificateur m1
contract firstcontract{
string public word="bonjour";
int public nombre1;
uint nombre2=200;
address owner=msg.sender;

function get()constant returns(uint,string){

return (nombre2, word);
}

modifier onlyowner{
if (msg.sender!=owner){
throw;
}
 _;
}
function set(int nb)onlyowner{
nombre1=nb;
}
}
pragma solidity ^0.4.7;
contract firstcontract{
string public word;
int public nombre1;
uint nombre2;
address owner;

constructor(string nwword,int nbr1,uint nbr2 ){

word=nwword;
nombre1=nbr1;
nombre2=nbr2;
owner=msg.sender;

}
function get()constant public returns(uint,string){
return (nombre2, word);
}

modifier onlyowner{
require (msg.sender==owner);
_;
}

event change(address n);

function set(int nb)onlyowner public{
nombre1=nb;
change(msg.sender);
}
}