Un smart contract Ethereum est un programme stocké sur la blockchain, exécuté de manière identique par tous les nœuds. Contrairement à un serveur classique (qui peut être hors ligne, piraté ou modifié), un smart contract est : permanent (impossible à supprimer), transparent (le code est public), et coûteux (chaque opération coûte du gaz). Ces propriétés le rendent utile pour automatiser des règles financières sans intermédiaire.
Comment fonctionne vraiment un smart contract
Quand tu appelles une fonction d’un smart contract :
1. Tu envoies une transaction contenant l’appel
2. Les validateurs regroupent ça dans un bloc
3. L’EVM exécute le code ligne par ligne
4. L’état du contrat (variables) est modifié
5. Tous les nœuds voient le même résultat
C’est ça qui rend les smart contracts fiables : pas de « serveur a crashé », pas de « données perdues », pas d’ambiguïté sur qui a raison.
État et fonctions : modèles mentaux
Un smart contract a :
État : les variables stockées (solde, owner, paramètres). C’est comme une base de données.
Fonctions : les actions possibles. Certaines lisent (vue), d’autres modifient (payantes en gaz).
Exemple : un contrat de vote a
— État : voters [adresse] => a voté ? votes [option] => compteur
— Fonctions : vote(option), tallyVotes(), getWinner()
Gaz : la vraie ressource limitée
Le gaz est le « carburant » Ethereum. Chaque instruction Solidity a un coût :
— Lire une variable = ~3 gaz
— Écrire une variable = ~20 000 gaz (très cher!)
— Appel externe = ~600 gaz minimum
Un simple transfer ERC-20 coûte ~65 000 gaz. À 20 gwei/gaz, ça fait ~0.0013 ETH (~2€ en temps normal).
Plus ton code est optimisé, moins il coûte. C’est pourquoi les vrais projets agonisent sur chaque ligne.
Déployer sur testnet vs mainnet
Testnet (Sepolia) : une copie d’Ethereum où les transactions sont gratuites. Tu déploies là d’abord, tu testes, tu corriges.
Commande : `npx hardhat run scripts/deploy.js –network sepolia`
Mainnet : le vrai réseau. Les transactions coûtent de l’argent réel et il n’y a pas « undo ».
Toujours tester en profondeur sur testnet avant de déployer sur mainnet.
Vérification et audit
Après le déploiement, tu dois « vérifier » le contrat sur Etherscan. Cela rend le code public et auditable.
Les étapes :
1. Déploie le contrat
2. Récupère l’adresse
3. Va sur Etherscan, cherche l’adresse
4. Clique « Verify and Publish » et colle le code
5. Les gens peuvent maintenant lire le code
Pour les projets sérieux, une vérification par un auditeur externe (firme de sécurité) renforce la confiance.
Risques : bugs et immuabilité
Une fois déployé, le code ne peut pas être changé (sauf si tu utilises un proxy upgrading, qui ajoute de la complexité).
Les bugs courants :
Reentrancy : un contrat t’appelle récursivement avant que ton état soit à jour.
Integer overflow/underflow : un nombre dépasse ses limites.
Logic errors : tu pensais que X se passe, mais en réalité Y se passe.
Tester TRÈS en détail avant de déployer est obligatoire.
Exemple concret : un contrat simple
`pragma solidity ^0.8.0;
contract Counter {
uint256 public count = 0;
function increment() public {
count += 1;
}
function decrement() public {
require(count > 0);
count -= 1;
}
}`
Ici : deux états (count), deux fonctions (increment, decrement). Simple, compréhensible, testable.
Conclusion
Un smart contract est un programme permanent, transparent et coûteux. Tu dois optimiser pour le gaz, tester exhaustivement, et accepter que tu ne peux pas corriger les bugs après le déploiement. Mais en retour, tu obtiens automatisation sans intermédiaire et confiance vérifiable.
—
