Premiers pas
Bases des contrats
Solidity est le langage principal des smart contracts Ethereum. pragma règle la version du compilateur. Un contrat ressemble à une classe. Les fonctions peuvent être public, private, view (lecture seule) ou payable.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract SimpleStorage {
uint256 storedData;
function set(uint256 x) public {
storedData = x;
}
function get() public view returns (uint256) {
return storedData;
}
}Pragma et version du compilateur
pragma spécifie la version du compilateur. ^0.8.0 autorise tout patch 0.8.x. En production, verrouillez la version exactement (0.8.19) pour éviter les surprises. Incluez toujours le pragma en tête de chaque fichier .sol.
// Lock to a single version
pragma solidity 0.8.19;
// Allow patches (^0.8.0 means >=0.8.0 <0.9.0)
pragma solidity ^0.8.0;
// Range of versions
pragma solidity >=0.8.0 <0.9.0;
// Experimental features (ABIEncoderV2 in older versions)
pragma experimental ABIEncoderV2;Commentaires et NatSpec
Les commentaires NatSpec (/// ou /** */) génèrent de la documentation. @notice pour les utilisateurs finaux, @dev pour les développeurs, @param décrit les paramètres, @return les valeurs de retour. Ils sont relevés par des outils comme Etherscan et Remix.
// Single-line comment
/* Multi-line
comment */
/// @title A Simple Contract
/// @author Alice
/// @notice This is visible to end users
/// @dev This is for developers
contract Commented {
/// @notice Sets the value
/// @param _x The new value
/// @dev Internal details here
function set(uint256 _x) public {}
}Licence SPDX
Depuis Solidity 0.6.8, l'identifiant de licence SPDX est obligatoire en tête de fichier. Il aide outils et utilisateurs à comprendre comment le code peut être réutilisé. Utilisez MIT pour de l'open source permissif, GPL-3.0 pour du copyleft, ou UNLICENSED pour du code privé.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// Common licenses:
// MIT - permissive
// GPL-3.0 - copyleft
// Apache-2.0 - permissive with patent grant
// UNLICENSED - private/no license
// BSD-2-Clause, BSD-3-Clause
contract Licensed {}Structure de fichier et imports
Les imports apportent contrats, bibliothèques ou interfaces. Utilisez {Nom} pour n'importer que des éléments précis. Les chemins relatifs marchent comme attendu. Le mot-clé 'is' établit l'héritage. Les fichiers ont typiquement un contrat principal mais peuvent en contenir plusieurs.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./OtherContract.sol";
import {SpecificContract, Helper} from "./Library.sol";
import * as Lib from "./Library.sol"; // namespace
import "openzeppelin/contracts/token/ERC20.sol";
contract MyContract is OtherContract {
// ...
}Types de valeur
Entiers (uint / int)
uint = entier non signé (pas de négatifs), int = signé. Les tailles vont de 8 à 256 par pas de 8. uint passe par défaut à uint256. Depuis 0.8.0, l'arithmétique vérifie automatiquement overflow/underflow et annule. Utilisez type(T).max / type(T).min pour obtenir les bornes.
uint256 public bigNumber = 1 ether; // 10^18
uint8 public small = 255; // max 255
int256 public signed = -100;
uint public defaultSize = 42; // uint256 by default
// Arithmetic
uint256 a = 10;
uint256 b = 3;
uint256 sum = a + b; // 13
uint256 diff = a - b; // 7 (0.8+ reverts on underflow)
uint256 product = a * b; // 30
uint256 quotient = a / b; // 3
uint256 remainder = a % b; // 1
uint256 power = a ** 2; // 100
// Type min/max (0.8+)
uint256 max = type(uint256).max;
int256 min = type(int256).min;Booléen
bool ne peut être que true ou false. && et || court-circuitent, c'est-à-dire que le côté droit n'est évalué que si nécessaire. Valeur par défaut false. Les booléens coûtent plus de gaz que uint256 dans certains contextes (packing de stockage).
bool public flag = true;
bool public negated = !flag; // false
bool public and = flag && false; // false
bool public or = flag || false; // true
// Short-circuit evaluation
bool result = (flag && expensiveCall()); // skips call if flag false
bool result2 = (!flag || expensiveCall());
// Equality
bool equal = (1 == 1); // true
bool notEq = (1 != 2); // true
// Boolean defaults to false
bool public defaultValue; // falseAdresse
address contient une adresse Ethereum de 20 octets. address payable peut recevoir des Ether (a des méthodes transfer/send). Utilisez payable(x) pour convertir. Les adresses ont la propriété .balance (en wei). Vérifiez toujours les littéraux d'adresse contre la somme de contrôle EIP-55 pour attraper les typos.
address public owner = msg.sender;
address payable public treasury = payable(owner);
// Balance (read-only)
uint256 bal = owner.balance; // in wei
// Send Ether (payable address only)
treasury.transfer(1 ether);
bool sent = treasury.send(1 ether);
// Convert from address to payable
address addr = 0x123...;
address payable payableAddr = payable(addr);
// Address literals (checksummed)
address public constant BURN = 0x000000000000000000000000000000000000dEaD;
// Compare addresses
bool same = (addr1 == addr2);Bytes et tableaux d'octets
Les bytes fixes (bytes1..bytes32) sont bon marché et utilisés pour hashs/sélecteurs. Le bytes dynamique sert aux données binaires brutes ; string au texte UTF-8. Utilisez bytes32 pour les hashs (keccak256 retourne bytes32). bytes.concat() (0.8.4+) est moins cher que abi.encodePacked pour les tableaux d'octets.
// Fixed-size byte arrays (bytes1 to bytes32)
bytes32 public hash = keccak256(abi.encodePacked("data"));
bytes1 public b1 = 0x41; // single byte
bytes4 public selector = bytes4(keccak256("transfer(address,uint256)"));
// Dynamic byte arrays
bytes public dynamic = "hello";
bytes public empty;
// String vs bytes
string public text = "Hello"; // UTF-8 string
bytes public raw = bytes(text);
// Operations on fixed bytes
bytes32 data = keccak256(abi.encode("x"));
bytes1 first = data[0]; // access by index
uint256 length = data.length; // 32
// Concatenation
bytes memory combined = bytes.concat(bytes("a"), bytes("b"));Enums
Les enums définissent un ensemble fini de valeurs nommées. Stockés en uint8 (256 membres max). Valeur par défaut : le premier membre (index 0). Convertissez entre enum et uint par casts. type(NomEnum).max donne le membre le plus haut.
contract EnumExample {
enum Status { Pending, Active, Paused, Closed }
Status public status = Status.Pending;
function activate() public {
require(status == Status.Pending, "Not pending");
status = Status.Active;
}
function next() public {
// Cast to uint to do math
uint current = uint(status);
if (current < uint(type(Status).max)) {
status = Status(current + 1);
}
}
// Default value is the first member (Pending)
Status public defaultValue; // Pending
}Conversion et casting de types
Les conversions implicites n'arrivent que si aucune perte de données n'est possible (uint8 -> uint256). Pour les conversions rétrécissantes (uint256 -> uint8) ou signé/non signé, utilisez des casts explicites. Convertir un int négatif en uint produit un nombre énorme à cause du complément à deux.
// Implicit conversion (safe, widening)
uint8 small = 10;
uint256 big = small; // OK: uint8 fits in uint256
// Explicit conversion (narrowing, may lose data)
uint256 large = 300;
uint8 narrow = uint8(large); // truncates to 44 (300 % 256)
// Address conversion
address addr = 0xAb8483F64d9C6d1Ec37F8D2C4fA6bA5d5C5e5C5e;
address payable payableAddr = payable(addr);
// Bytes conversion
bytes32 b32 = bytes32(uint256(42));
uint256 num = uint256(b32);
bytes4 selector = bytes4(keccak256("foo()"));
// String <-> bytes
string memory s = "hi";
bytes memory bs = bytes(s);
string memory s2 = string(bs);
// int <-> uint (explicit, watch for negatives)
int256 signed = -5;
uint256 unsigned = uint256(signed); // huge number!Types de référence
String
Les chaînes Solidity sont des tableaux d'octets UTF-8 — length() retourne un compte d'octets, pas de caractères (emoji/caractères multioctets diffèrent). L'égalité doit se vérifier via le hash keccak256. string.concat (0.8.12+) est moins cher que abi.encodePacked. Les chaînes coûtent cher en gaz.
contract Strings {
string public greeting = "Hello, World!";
function concat(string memory a, string memory b)
public pure returns (string memory)
{
return string.concat(a, " ", b); // 0.8.12+
}
function length(string memory s) public pure returns (uint256) {
return bytes(s).length; // byte length, not char count
}
function equals(string memory a, string memory b)
public pure returns (bool)
{
return keccak256(bytes(a)) == keccak256(bytes(b));
}
// Storage string (state variable)
string public stored;
function set(string memory s) public { stored = s; }
}Tableaux (fixes et dynamiques)
Les tableaux fixes [N] ont une taille à la compilation ; les dynamiques [] croissent avec push/pop. Les tableaux en mémoire doivent être créés avec 'new Type[](taille)'. Lire/écrire des tableaux de stockage coûte du gaz ; préférez memory pour les données temporaires. push() retourne une référence en 0.6+.
contract Arrays {
// Fixed-size array
uint256[5] public fixedArr = [1, 2, 3, 4, 5];
// Dynamic array
uint256[] public dynamicArr;
function pushPop() public {
dynamicArr.push(10); // append: [10]
dynamicArr.push(20); // [10, 20]
dynamicArr.pop(); // remove last: [10]
}
function getLength() public view returns (uint256) {
return dynamicArr.length;
}
function iterate() public view returns (uint256 sum) {
for (uint256 i = 0; i < dynamicArr.length; i++) {
sum += dynamicArr[i];
}
}
// Array of arrays (2D)
uint256[][] public matrix;
// Memory array (must have fixed length when created)
function memArray() public pure returns (uint256[] memory) {
uint256[] memory arr = new uint256[](3);
arr[0] = 1; arr[1] = 2; arr[2] = 3;
return arr;
}
}Structs
Les structs groupent des champs liés. Ils peuvent être stockés en storage, memory ou passés en arguments de fonction. Définissez-les au niveau fichier ou contrat. L'initialisation avec champs nommés {champ: valeur} est plus claire ; positionnelle plus courte. Les valeurs de mapping ne peuvent pas être accédées comme un struct entier dans les vieilles versions.
contract Structs {
struct User {
address wallet;
uint256 balance;
bool active;
string name;
}
// Single struct (storage)
User public owner;
User[] public users; // array of structs
mapping(address => User) public userByAddr;
function createUser(string memory name) public {
User memory u = User({
wallet: msg.sender,
balance: 100,
active: true,
name: name
});
users.push(u);
}
// Shorter syntax
function createShort() public {
users.push(User(msg.sender, 50, true, "anon"));
}
// Update a field
function deactivate(uint256 index) public {
users[index].active = false; // direct storage write
}
}Mappings
Les mappings sont des tables de hachage : keccak256(clé) => valeur. Sans longueur, non itérables. Les clés peuvent être des types de valeur (uint, address, bytes, enum) ; les valeurs n'importe quoi. Les mappings imbriqués permettent des lookups multi-clés. Pour itérer, maintenez un tableau séparé de clés. delete réinitialise une clé à sa valeur zéro.
contract Mappings {
// keyType => valueType
mapping(address => uint256) public balances;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public isRegistered;
function setBalance(uint256 amount) public {
balances[msg.sender] = amount;
}
function approve(address spender, uint256 amount) public {
allowance[msg.sender][spender] = amount;
}
function register() public {
isRegistered[msg.sender] = true;
}
// Iterable mapping pattern
address[] public userList;
mapping(address => bool) public exists;
function addUser(address u) public {
if (!exists[u]) {
userList.push(u);
exists[u] = true;
}
}
// CANNOT iterate or get length of a mapping directly
// CANNOT delete a mapping, only individual keys
function remove() public {
delete balances[msg.sender]; // sets to 0
}
}Emplacements de données (storage / memory / calldata)
storage = état persistant on-chain (cher). memory = temporaire, vit pendant l'appel de fonction (bon marché). calldata = lecture seule, réservé aux entrées de fonctions external (le moins cher). Utilisez toujours calldata pour les arguments de fonctions external que vous ne lisez que. Emplacement par défaut : les variables d'état sont en storage ; les types complexes locaux de fonction passent par défaut en memory.
contract DataLocations {
string public stateVar; // storage (state)
function f(string calldata input) external {
// calldata: read-only, only for external function args
string memory local = input; // memory: temporary copy
stateVar = local; // writes to storage
// storage reference (only inside a function)
string storage ref = stateVar;
ref = "new value"; // modifies stateVar
}
// External params can be calldata (cheapest)
function g(string calldata s) external pure returns (bytes32) {
return keccak256(bytes(s));
}
// Public/internal params default to memory
function h(string memory s) public pure returns (uint256) {
return bytes(s).length;
}
// Assignment rules:
// storage -> storage: reference (both point to same slot)
// memory -> memory: reference (both point to same memory)
// storage <-> memory: copy
}Structures imbriquées
Les structs peuvent contenir tableaux, mappings (seulement en storage) et autres structs. Accéder aux champs d'un struct imbriqué via une référence de stockage est efficace en gaz. Attention à l'imbrication profonde — elle augmente l'usage des slots de stockage et le coût de déploiement. Le mapping-de-struct est le pattern de base de données on-chain le plus courant.
contract Nested {
struct Order {
uint256 id;
uint256 amount;
Item[] items;
}
struct Item {
string sku;
uint256 qty;
}
mapping(uint256 => Order) public orders;
Order[] public allOrders;
function addOrder(uint256 id, string memory sku, uint256 qty) public {
Order storage o = orders[id];
o.id = id;
o.amount += qty * 1 ether;
o.items.push(Item(sku, qty));
}
// Mapping of struct arrays
mapping(address => Item[]) public userItems;
// Struct in a struct
struct Profile {
User user;
uint256 score;
}
struct User {
address addr;
string name;
}
Profile public profile;
}Variables d'état
Variables d'état publiques et privées
Les variables d'état publiques génèrent automatiquement une fonction getter. private restreint l'accès au contrat ; internal autorise aussi les sous-classes. Défaut : internal. CRUCIAL : 'private' ne signifie PAS secret — toutes les données blockchain sont publiquement lisibles. Utilisez chiffrement/hachage si vous avez besoin de confidentialité.
contract Visibility {
uint256 public publicVar = 1; // auto getter created
uint256 private privateVar = 2; // only this contract
uint256 internal internalVar = 3; // this + subclasses
// No 'external' for state variables
// internal is the default
uint256 defaultVar = 4; // internal
function readPrivate() public view returns (uint256) {
return privateVar; // readable from inside
}
// 'private' only means 'not via other contracts'.
// The data is still visible on-chain!
}
// public creates an automatic getter:
// function publicVar() external view returns (uint256) { return publicVar; }Variables constant
Les variables constant s'évaluent à la compilation et s'inline dans le bytecode — coût de gaz nul à l'exécution (pas de SLOAD). Seuls les types de valeur (uint, address, bytes, etc.) peuvent être constant. La valeur doit être une expression de compilation. Utilisez constant pour les valeurs fixes comme MAX_SUPPLY, DECIMALS, adresses.
contract Constants {
// constant: evaluated at compile time, inlined into code
uint256 public constant MAX_SUPPLY = 1_000_000 * 10**18;
address public constant DEAD = 0x000000000000000000000000000000000000dEaD;
uint8 public constant DECIMALS = 18;
// Must be value types, assigned a literal/expression
// No assignment in constructor
// Numeric separators (1_000_000) work since 0.8.0
function compute() public pure returns (uint256) {
return MAX_SUPPLY / 2; // inlined, no SLOAD
}
}Variables immutable
Les variables immutable se règlent une fois dans le constructeur puis deviennent lecture seule. Stockées dans le bytecode (pas le storage), donc leurs lectures coûtent moins que les variables d'état ordinaires. Contrairement à constant, immutable peut utiliser les arguments du constructeur et des valeurs d'exécution. Utilisez immutable pour ce qui se règle au déploiement : owner, nom du token, config propre à la chaîne.
contract Immutable {
// immutable: set once in constructor, then read-only
address public immutable owner;
uint256 public immutable creationBlock;
constructor(address _owner) {
owner = _owner;
creationBlock = block.number;
}
// Can be any value type
// Cheaper than regular state vars (no SLOAD slot, uses code)
// More flexible than constant (can use constructor args)
function check() public view returns (bool) {
return msg.sender == owner; // cheap read
}
}
// Use case: factory-deployed contracts with constructor args
contract Factory {
Child[] public children;
function create(address owner) public {
children.push(new Child(owner));
}
}
contract Child {
address public immutable owner;
constructor(address _owner) { owner = _owner; }
}Variables globales (msg, tx, block)
msg fournit le contexte d'appel : msg.sender (appelant immédiat), msg.value (wei envoyés), msg.data (calldata brut), msg.sig (sélecteur de fonction). tx donne les infos de transaction : tx.origin (l'EOA, NON recommandé pour l'auth). block donne le bloc courant : block.timestamp, block.number, block.chainid, block.coinbase. N'utilisez jamais tx.origin pour l'autorisation — utilisez msg.sender.
contract Globals {
function msgVars() public view returns (
address sender,
bytes4 selector,
uint256 value,
bytes memory data
) {
sender = msg.sender; // caller address
selector = msg.sig; // function selector
value = msg.value; // wei sent with tx
data = msg.data; // full calldata
}
function txVars() public view returns (address origin, uint256 gasprice) {
origin = tx.origin; // EOA that started the tx
gasprice = tx.gasprice; // gas price in wei
}
function blockVars() public view returns (
uint256 number,
uint256 timestamp,
address miner,
uint256 chainId
) {
number = block.number; // current block height
timestamp = block.timestamp; // current block time (uint256 in 0.8+)
miner = block.coinbase; // block miner/validator
chainId = block.chainid; // chain ID
}
}Propriétés de bloc et tx
blockhash() ne retourne des hashs que pour les 256 derniers blocs ; plus anciens retourne 0. block.timestamp est réglé par le mineur et peut varier d'environ 15 secondes — ne l'utilisez jamais pour un timing précis ou l'aléatoire. block.basefee vient d'EIP-1559. gasleft() remplace le msg.gas déprécié. chainid est critique pour la protection de rejeu.
contract BlockProps {
function getBlockInfo() public view returns (
uint256 number,
uint256 timestamp,
uint256 gasLimit,
uint256 gasPrice,
uint256 baseFee
) {
number = block.number;
timestamp = block.timestamp;
gasLimit = block.gaslimit;
gasPrice = tx.gasprice;
baseFee = block.basefee; // EIP-1559 (London)
}
function getChainId() public view returns (uint256) {
return block.chainid;
}
function getPrevHash(uint256 n) public view returns (bytes32) {
require(n < 256, "out of range");
return blockhash(block.number - n); // last 256 blocks
}
function gasLeft() public view returns (uint256) {
return gasleft(); // remaining gas
}
}Fonctions
Syntaxe de fonction
Syntaxe : function nom(params) visibilité mutabilité returns(...). La visibilité (public/external/internal/private) est requise. La mutabilité (pure/view/payable) est optionnelle mais recommandée. Les valeurs de retour multiples sont supportées. Les retours nommés permettent de leur affecter directement et de sauter le mot-clé return.
contract Func {
// function name(params) <visibility> <state-mutability> returns(...)
function add(uint256 a, uint256 b)
public
pure
returns (uint256)
{
return a + b;
}
// Multiple returns
function split(uint256 x)
public pure returns (uint256, uint256)
{
return (x / 2, x % 2);
}
// Named returns (no explicit return needed)
function named(uint256 x)
public pure returns (uint256 half, uint256 rest)
{
half = x / 2;
rest = x % 2;
// return statement optional
}
// Destructure returns
function caller() public pure returns (uint256) {
(uint256 h, uint256 r) = named(10);
return h + r;
}
}Fonctions view
Les fonctions view peuvent lire l'état sans le modifier. Appelées en externe via eth_call, elles sont gratuites (pas de frais de gaz). Appelées en interne depuis une fonction modifiante, elles consomment du gaz. Utilisez view pour toute fonction qui ne fait que lire l'état — cela signale l'intention et permet des lectures gratuites hors chaîne.
contract ViewFn {
uint256 public counter = 0;
// view: can READ state but not modify
function getCount() public view returns (uint256) {
return counter; // reading state
}
function doubleCount() public view returns (uint256) {
return counter * 2; // reading state
}
// Can call other view/pure functions
function combined() public view returns (uint256) {
return getCount() + 1;
}
// CANNOT:
// - write to state variables
// - emit events
// - call non-view functions
// - use selfdestruct
// - send Ether
// view functions can be called off-chain for free (eth_call)
}Fonctions pure
Les fonctions pure ne peuvent ni lire ni écrire l'état — elles ne calculent que sur leurs entrées. Les plus restreintes et les moins chères à appeler hors chaîne. Utilisez pure pour des fonctions utilitaires (maths, hachage d'entrées). Si vous avez besoin de msg.sender ou des données de bloc, utilisez view. pure ne peut appeler que d'autres fonctions pure.
contract PureFn {
// pure: cannot read OR write state
function add(uint256 a, uint256 b) public pure returns (uint256) {
return a + b;
}
function square(uint256 x) public pure returns (uint256) {
return x * x;
}
// pure can only use:
// - function parameters
// - local memory variables
// - other pure functions
function combined(uint256 x) public pure returns (uint256) {
uint256 y = square(x); // calling another pure fn
return add(y, 1);
}
// CANNOT read: state variables, msg.sender, block.timestamp, etc.
// CANNOT call view functions
}Fonctions payable
Les fonctions payable peuvent recevoir des Ether via msg.value. Les Ether s'ajoutent automatiquement au solde du contrat. Seules les fonctions payable et receive/fallback peuvent accepter des Ether. Validez toujours msg.value si vous attendez un montant précis. Les fonctions non payable annulent si des Ether sont envoyés.
contract Payable {
address payable public owner;
constructor() {
owner = payable(msg.sender);
}
// payable: function can receive Ether
function deposit() public payable {
// msg.value is the amount of wei sent
// Ether is automatically added to contract balance
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
// Withdraw to owner
function withdraw() public {
require(msg.sender == owner, "not owner");
owner.transfer(address(this).balance);
}
// payable address (the contract itself can be paid)
receive() external payable {
// called when calldata is empty + value sent
}
}Valeurs de retour et retours nommés
Les fonctions peuvent retourner plusieurs valeurs via tuples. Les retours nommés améliorent la lisibilité et permettent d'affecter directement sans instruction return. Les return explicites surchargent les retours nommés. Utilisez le déstructurage (a, b) = f() pour capturer plusieurs retours ; (, b) ou (a,) pour sauter les valeurs inutiles.
contract Returns {
// Single return
function one() public pure returns (uint256) {
return 42;
}
// Multiple returns
function two() public pure returns (uint256, bool) {
return (1, true);
}
// Named returns — assign directly
function named() public pure returns (uint256 a, uint256 b) {
a = 1;
b = 2;
// no return keyword needed
}
// Mixed: explicit return overrides
function mixed(bool x) public pure returns (uint256 a, uint256 b) {
a = 1;
if (x) return (10, 20); // explicit return
b = 2;
}
// Destructuring assignment
function caller() public pure returns (uint256) {
(uint256 x, uint256 y) = two();
return x + y;
}
// Skip values with commas
function skip() public pure returns (bool) {
(, bool y) = two();
return y;
}
}Surcharge de fonctions
Solidity supporte la surcharge de fonctions : plusieurs fonctions de même nom mais de types ou comptes de paramètres différents. Le compilateur résout laquelle appeler selon les types d'arguments. Le type de retour seul ne peut distinguer les surcharges. Utiles pour accepter à la fois address et address payable, ou des plages de nombres différentes.
contract Overload {
// Same name, different parameter types/counts
function add(uint256 a, uint256 b) public pure returns (uint256) {
return a + b;
}
function add(uint256 a, uint256 b, uint256 c) public pure returns (uint256) {
return a + b + c;
}
function add(string memory a, string memory b)
public pure returns (string memory)
{
return string.concat(a, b);
}
// Caller selects which via argument types
function test() public pure returns (uint256, uint256, string memory) {
return (add(1, 2), add(1, 2, 3), add("a", "b"));
}
// NOTE: return type alone does NOT distinguish overloads
// function f() returns (uint256) and f() returns (bool) — INVALID
}Constructeur et fonctions spéciales
Constructeur
constructor tourne une fois au déploiement du contrat, pour initialiser l'état. Non rappelable ensuite. Les arguments du constructeur s'ajoutent au bytecode de déploiement ou passent via l'ABI selon le framework. Pour l'héritage, passez les arguments du constructeur parent dans la liste d'héritage (Owned(_owner)) ou style modificateur (A() B()).
contract Owned {
address public owner;
// constructor runs once at deployment
constructor(address _owner) {
owner = _owner;
}
modifier onlyOwner() {
require(msg.sender == owner, "not owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
}
// Inheritance: constructor args
contract Child is Owned {
constructor(address _owner) Owned(_owner) {}
}
// No constructor = default constructor (no args)
contract NoCtor {}
// Multiple inheritance: order matters
contract A { constructor() {} }
contract B { constructor() {} }
contract C is A, B {
constructor() A() B() {}
}Fonction receive
receive() est invoquée quand un appel sans calldata envoie des Ether (ex. send/transfer vers le contrat). Elle doit être 'external payable' sans arguments ni retours. Une seule fonction receive autorisée. En son absence et sans fallback, les transferts d'Ether simples annulent (sauf via selfdestruct qui peut forcer des Ether).
contract Receiver {
event Received(address from, uint256 amount);
// receive: called on plain Ether transfers (no calldata)
// Must be 'external payable', no args, no returns
// Only ONE receive per contract
receive() external payable {
emit Received(msg.sender, msg.value);
}
// Triggered by: transfer(), send(), or empty calldata tx
// Use this to react to incoming Ether
function balance() public view returns (uint256) {
return address(this).balance;
}
}
// If no receive/fallback exists, the contract rejects plain Ether.
// Exception: contracts can be forced via selfdestruct (always).Fonction fallback
fallback() est appelée quand aucune fonction ne correspond au sélecteur, ou quand receive est absente et qu'un transfert d'Ether simple est tenté. Elle peut être payable. Gardez la logique du fallback minimale — invoquée via send()/transfer(), elle n'a que 2300 gaz (la dotation), insuffisant pour des écritures de stockage ou l'émission d'événements.
contract Fallback {
event Log(string message, address from, uint256 value, bytes data);
// fallback: called when no function matches the calldata
// OR when receive is absent and calldata is empty
fallback() external payable {
emit Log("fallback", msg.sender, msg.value, msg.data);
}
// With calldata (function not found)
// Without calldata + no receive => fallback runs
// Modern: separate receive and fallback
// receive() external payable { ... } // empty calldata + value
// fallback() external payable { ... } // unknown function
// Make fallback cheap — it can run out of gas on send()/transfer() (2300 stipend)
function safeFallback() external {
// logic here must be < 2300 gas if called via transfer/send
}
}Selfdestruct
selfdestruct envoie tous les Ether restants à une adresse précise et (avant Dencun) retire le code du contrat. Après EIP-6780 (mars 2024), il ne retire le code que si appelé dans la même transaction de déploiement — sinon il transfère juste les Ether. Ne comptez jamais sur selfdestruct pour la sécurité : des Ether forcés peuvent arriver, et le code peut persister.
contract SelfDestruct {
address payable public owner;
constructor() { owner = payable(msg.sender); }
function destroy() public {
require(msg.sender == owner, "not owner");
// Sends all Ether to recipient, then deletes the contract
selfdestruct(payable(msg.sender));
}
}
// IMPORTANT WARNINGS:
// - After EIP-6780 (Dencun), selfdestruct no longer deletes code
// unless called in the same transaction that deployed the contract
// - It still sends all Ether to the recipient
// - The recipient could be a contract with no receive/fallback and
// it still gets the Ether (forced transfer)
// - Do NOT rely on selfdestruct for security; prefer a 'paused' flagSélecteur de fonction
Chaque fonction a un sélecteur de 4 octets = les 4 premiers octets de keccak256(signature). La signature est le nom de la fonction et les types de paramètres sans espaces, ex. 'transfer(address,uint256)'. L'EVM utilise le sélecteur pour router les appels. msg.sig donne le sélecteur de la fonction courante. abi.encodeWithSelector/Signature bâtissent le calldata pour les appels bas niveau.
contract Selector {
// First 4 bytes of keccak256 of the function signature
// signature = "functionName(paramType1,paramType2,...)"
bytes4 public constant SELECTOR =
bytes4(keccak256("transfer(address,uint256)"));
function getSelector() public pure returns (bytes4) {
return bytes4(keccak256("transfer(address,uint256)")));
// = 0xa9059cbb
}
function thisSelector() public pure returns (bytes4) {
return msg.sig; // selector of the currently running function
}
// Used for low-level calls
function callTransfer(address token, address to, uint256 amount)
public returns (bool, bytes memory)
{
(bool ok, bytes memory data) = token.call(
abi.encodeWithSelector(0xa9059cbb, to, amount)
);
return (ok, data);
}
// abi.encodeWithSignature uses the string form
function altCall(address token, address to, uint256 amount)
public returns (bool, bytes memory)
{
return token.call(
abi.encodeWithSignature("transfer(address,uint256)", to, amount)
);
}
}Modificateurs
Bases des modificateurs
Les modificateurs enveloppent des fonctions avec des pré/post conditions réutilisables. Le placeholder _; est là où le corps de la fonction s'exécute. Les modificateurs sont parfaits pour contrôle d'accès (onlyOwner), validation (validInput) et gardes de réentrance. Ils s'appliquent avant le corps de la fonction par défaut — utilisez _; pour contrôler où le corps tourne.
contract ModBasics {
address public owner;
uint256 public count;
constructor() { owner = msg.sender; }
// Define a modifier
modifier onlyOwner() {
require(msg.sender == owner, "not owner");
_; // placeholder for the function body
}
// Apply it
function increment() public onlyOwner {
count += 1;
}
function reset() public onlyOwner {
count = 0;
}
// Anyone can read
function getCount() public view returns (uint256) {
return count;
}
}Modificateur avec arguments
Les modificateurs peuvent prendre des arguments, les rendant flexibles. Les arguments s'évaluent au site d'appel et se lient quand le modificateur tourne. Patterns courants : costs(price) pour payer-par-appel, onlyRole(role) pour RBAC, rateLimit(window) pour le throttling. La logique avant _; est une pré-condition, après _; une post-condition.
contract ModArgs {
modifier costs(uint256 price) {
require(msg.value >= price, "insufficient payment");
_;
// optional: refund excess after function runs
if (msg.value > price) {
payable(msg.sender).transfer(msg.value - price);
}
}
modifier onlyAddress(address allowed) {
require(msg.sender == allowed, "not allowed");
_;
}
function buyItem() public payable costs(1 ether) {
// msg.value must be >= 1 ether to enter
// excess refunded after body runs
}
function adminOnly() public onlyAddress(0xAbC...) {
// restricted to a hardcoded address
}
}Modificateurs multiples
Une fonction peut avoir plusieurs modificateurs. Ils s'exécutent dans l'ordre, enveloppant le corps comme une pile : la pré-condition du premier modificateur tourne d'abord, puis le second, ..., puis le corps, puis ils se déroulent en sens inverse. L'ordre compte — mettez d'abord les vérifications les moins chères / les plus susceptibles d'échouer pour économiser le gaz.
contract MultiMod {
address public owner;
bool public paused;
uint256 public value;
constructor() { owner = msg.sender; }
modifier onlyOwner() {
require(msg.sender == owner, "not owner");
_;
}
modifier whenNotPaused() {
require(!paused, "paused");
_;
}
modifier validValue(uint256 v) {
require(v > 0, "invalid value");
_;
}
// Multiple modifiers — executed in order
// Stack-like: A B body B' A'
function setValue(uint256 v)
public
onlyOwner // 1. check owner
whenNotPaused // 2. check not paused
validValue(v) // 3. validate input
{
value = v;
}
}Ordre des modificateurs et gaz
L'ordre des modificateurs affecte le gaz et la clarté. Vérifications bon marché d'abord (booléens, comparaisons d'adresses) et coûteuses à la fin (écritures de stockage, appels externes). Mettez aussi en premier les vérifications les plus susceptibles d'échouer — court-circuit et remboursement du gaz inutilisé. Documentez l'ordre voulu par commentaires.
contract ModOrder {
// Order modifiers from cheapest to most expensive
// OR most likely to fail first (to short-circuit)
modifier onlyOwner() { require(msg.sender == owner, "1"); _; }
modifier nonZero(uint256 x) { require(x != 0, "2"); _; }
modifier withinRange(uint256 x) {
require(x >= 1 && x <= 100, "3");
_;
}
modifier notPaused() { require(!paused, "4"); _; }
// Good order: cheap + likely-to-fail first
function good(uint256 x)
public
notPaused // 1. cheap bool check
onlyOwner // 2. address compare
nonZero(x) // 3. cheap input check
withinRange(x) // 4. more complex range check
{}
address public owner;
bool public paused;
constructor() { owner = msg.sender; }
}Patterns de modificateurs courants
Patterns courants : nonReentrant (poser un verrou avant le corps, le lever après), whenNotPaused/whenPaused (disjoncteur), onlyRole (RBAC avec rôles bytes32), rateLimit (throttle par utilisateur via timestamps). La garde de réentrance est la plus importante — appliquez-la à toute fonction qui fait un appel externe après un changement d'état.
contract Patterns {
// 1. Reentrancy guard
uint256 private _status = 1;
modifier nonReentrant() {
require(_status == 1, "reentrant");
_status = 2;
_;
_status = 1;
}
// 2. Pausable
bool public paused;
modifier whenNotPaused() {
require(!paused, "paused");
_;
}
modifier whenPaused() {
require(paused, "not paused");
_;
}
// 3. Role-based
mapping(bytes32 => bool) public hasRole;
modifier onlyRole(bytes32 role) {
require(hasRole[role], "missing role");
_;
}
// 4. Rate limit (basic)
mapping(address => uint256) public lastCall;
modifier rateLimit() {
require(block.timestamp >= lastCall[msg.sender] + 1 minutes, "rate");
lastCall[msg.sender] = block.timestamp;
_;
}
}Événements
Déclaration et émission d'événements
Les événements se loguent sur la blockchain et sont lisibles par les clients hors chaîne (via eth_getLogs). Ils ne sont PAS lisibles par les autres contrats. Utilisez indexed sur jusqu'à 3 paramètres pour les rendre filtrables. Les événements coûtent moins de gaz que les écritures de stockage. Émettez toujours des événements pour les changements d'état importants afin que dApps et indexeurs réagissent.
contract Events {
// Declare event (outside functions, can be at file level)
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => uint256) public balances;
function transfer(address to, uint256 amount) public returns (bool) {
require(balances[msg.sender] >= amount, "insufficient");
balances[msg.sender] -= amount;
balances[to] += amount;
// Emit the event
emit Transfer(msg.sender, to, amount);
return true;
}
function approve(address spender, uint256 amount) public returns (bool) {
emit Approval(msg.sender, spender, amount);
return true;
}
}Paramètres indexés
Les paramètres indexed deviennent des topics filtrables par les clients hors chaîne (dApps, The Graph, indexeurs). Maximum 3 paramètres indexés par événement (le 4e topic est réservé au hash de signature de l'événement). Les types de valeur indexés (uint, address) se stockent directement ; les types de référence indexés (string, bytes, tableaux) se hachent en keccak256 et sont irrécupérables.
contract Indexed {
// Up to 3 indexed params (in non-anonymous events)
// Indexed params become 'topics' that clients can filter on
event OrderPlaced(
address indexed buyer, // topic 1
address indexed token, // topic 2
uint256 indexed orderId, // topic 3
uint256 amount, // data (not filterable)
uint256 price // data
);
function placeOrder(address token, uint256 amount, uint256 price)
public returns (uint256 id)
{
id = uint256(keccak256(abi.encodePacked(msg.sender, block.number)));
emit OrderPlaced(msg.sender, token, id, amount, price);
}
// Clients can filter:
// eth_getLogs({topics: [sig, buyerAddr, tokenAddr, orderId]})
//
// Indexed arrays/strings/bytes are hashed (keccak256) —
// you can't recover the original value, only compare hashes.
}Événements anonymes
Les événements anonymous sautent le hash de signature dans topic[0], libérant un slot — donc 4 paramètres indexés au lieu de 3. Le compromis : les clients ne peuvent pas filtrer par nom d'événement (signature), rendant plus difficile de distinguer plusieurs événements anonymes d'un contrat. Rarement utile ; l'économie de gaz est minime.
contract Anonymous {
// anonymous: skips storing the event signature as topic[0]
// So you can have up to 4 indexed params instead of 3
event Log(
address indexed from,
address indexed to,
uint256 indexed amount,
uint256 indexed timestamp, // 4th indexed (only with anonymous)
bytes data
) anonymous;
function log() public {
emit Log(msg.sender, address(0), 100, block.timestamp, "");
}
// Trade-offs:
// + 1 more indexed param allowed
// - Clients cannot filter by event signature
// - Harder to distinguish multiple anonymous events
// - Slightly cheaper gas
// Rarely used; prefer named events for clarity.
}Bonnes pratiques des événements
Bonnes pratiques : émettez après les changements d'état (pour que l'événement reflète l'état final), incluez des champs aidant les indexeurs à éviter des appels RPC supplémentaires (comme newBalance), évitez d'émettre dans des boucles serrées (batchez à la place), et indexez les champs les plus souvent filtrés (adresses, IDs, codes de statut). Les événements sont le canal principal de communication contrat-vers-hors-chaîne.
contract EventBest {
// 1. Name events with past tense or noun: Transfer, Deposit, OrderPlaced
event Transfer(address indexed from, address indexed to, uint256 value);
// 2. Emit AFTER state changes succeed
mapping(address => uint256) public balances;
function transfer(address to, uint256 amt) public {
balances[msg.sender] -= amt; // state first
balances[to] += amt;
emit Transfer(msg.sender, to, amt); // event after
}
// 3. Include enough data to reconstruct state
event Deposit(
address indexed account,
uint256 amount,
uint256 newBalance, // helps indexers avoid extra reads
uint256 timestamp
);
// 4. Don't emit in a loop — batch instead
event BatchTransfer(address[] to, uint256[] amounts);
function batch(address[] memory to, uint256[] memory amounts) public {
emit BatchTransfer(to, amounts); // one event, not N
}
// 5. Index the fields users filter on (addresses, IDs)
}Événements vs logs vs stockage
Le stockage est dans l'arbre d'état — lisible par les autres contrats et fonctions view, mais cher (~20k gaz par SSTORE). Les événements/logs sont dans l'arbre des receipts — NON lisibles par les contrats, mais bon marché (~1-2k gaz) et accessibles hors chaîne via eth_getLogs. Utilisez le stockage pour les décisions on-chain, les événements pour communiquer les changements d'état aux dApps et indexeurs.
contract Compare {
// Storage: persistent, readable by contracts, expensive
uint256 public storedValue; // SSTORE costs ~20k gas
// Events (logs): persistent-ish, NOT readable by contracts, cheap
event ValueChanged(uint256 oldValue, uint256 newValue);
function set(uint256 newValue) public {
uint256 old = storedValue;
storedValue = newValue; // SSTORE (~20k gas)
emit ValueChanged(old, newValue); // LOG (~1-2k gas)
}
// Logs live in the block's receipt trie, NOT the state trie.
// They are NOT accessible from other contracts.
// function readLog() public view returns (...) {
// CANNOT access emitted events
// }
// Off-chain tools (dApps, The Graph) read logs via eth_getLogs.
// Use storage for on-chain logic; events for off-chain observers.
}Gestion des erreurs
Require
require(cond, msg) annule la transaction et rembourse le gaz inutilisé si cond est faux. La primitive de validation la plus courante — pour les vérifications d'entrées, contrôle d'accès et préconditions. La chaîne de message coûte du gaz (stockée dans le bytecode déployé). Pour économiser, utilisez des erreurs custom (revert NomErreur()) au lieu de messages de chaînes.
contract Require {
mapping(address => uint256) public balances;
function deposit() public payable {
require(msg.value > 0, "must send ether");
balances[msg.sender] += msg.value;
}
function withdraw(uint256 amount) public {
// require(condition, message)
// Reverts with the message if condition is false
// Refunds all unused gas to the caller (post-0.8.0 with custom errors, also refunds)
require(balances[msg.sender] >= amount, "insufficient balance");
balances[msg.sender] -= amount;
payable(msg.sender).transfer(amount);
}
// Pre-0.8.0: require with no message was cheaper
// 0.8.4+: prefer custom errors (cheaper, see other item)
function cheap(uint256 x) public pure {
if (x == 0) revert ZeroValue(); // custom error
}
error ZeroValue();
}Revert
revert(msg) annule explicitement la transaction avec une chaîne de raison. Utilisez revert() dans des if quand vous avez besoin de logique de branchement (require n'est que du sucre syntaxique). revert() sans message est moins cher que revert("msg"). Les erreurs custom (revert NomErreur(args)) sont les moins chères et les plus descriptives — préférez-les dans le nouveau code.
contract Revert {
function explicit(uint256 x) public pure {
if (x == 0) {
revert("zero not allowed"); // explicit revert with message
}
if (x > 100) {
revert("too big"); // can place anywhere
}
}
// revert() with no message (cheapest string revert)
function silent(uint256 x) public pure {
if (x == 0) revert(); // no reason
}
// Custom error (0.8.4+) — recommended
error TooBig(uint256 given, uint256 max);
function custom(uint256 x) public pure {
if (x > 100) revert TooBig(x, 100);
}
// Inside an internal function, revert propagates up
function caller(uint256 x) public pure {
inner(x); // reverts here if x is bad
}
function inner(uint256 x) internal pure {
if (x == 0) revert("zero");
}
}Assert
assert(cond) sert aux invariants qui ne devraient jamais être faux si le code est correct — un assert échoué signale un bug. Avant 0.8.0, assert consommait tout le gaz ; depuis 0.8.0 il se comporte comme revert. Utilisez require pour la validation d'entrées et les conditions d'erreur attendues ; assert seulement pour des états impossibles signalant un bug. Les vérifications d'overflow automatiques modernes utilisent revert, pas assert.
contract Assert {
function check(uint256 x) public pure returns (uint256) {
uint256 result = x + 1;
// assert: for invariants that should NEVER be false
// If it fails, something is critically broken.
assert(result > x); // overflow check (auto in 0.8+)
return result;
}
// Pre-0.8.0: assert was used for overflow checks (used all gas)
// Post-0.8.0: arithmetic auto-checks use revert, not assert
//
// Modern guidance:
// - Use require/revert for input validation & expected failures
// - Use assert ONLY for invariants that indicate a code bug
// (something that should be impossible if the code is correct)
//
// Example: a state machine that should never reach an invalid state
enum State { Created, Paid, Shipped }
State public state;
function ship() public {
require(state == State.Paid, "not paid");
state = State.Shipped;
assert(state == State.Shipped); // invariant
}
}Erreurs personnalisées
Les erreurs custom (0.8.4+) sont la façon recommandée d'annuler. Elles s'encodent en un sélecteur de 4 octets plus des arguments ABI — bien moins cher que les messages de chaînes (stockés en UTF-8 complet dans le bytecode). Les clients décodent le sélecteur pour savoir quelle erreur est survenue et lire les arguments structurés. Définissez les erreurs au niveau fichier ou contrat, puis 'revert NomErreur(args);'.
contract CustomError {
// Define errors (outside functions, can be at file level)
error InsufficientBalance(uint256 available, uint256 required);
error Unauthorized(address caller);
error TransferFailed(address from, address to);
mapping(address => uint256) public balances;
function withdraw(uint256 amount) public {
if (balances[msg.sender] < amount) {
// Cheaper than require(..., "insufficient balance")
revert InsufficientBalance(balances[msg.sender], amount);
}
balances[msg.sender] -= amount;
(bool ok, ) = msg.sender.call{value: amount}("");
if (!ok) revert TransferFailed(address(this), msg.sender);
}
function adminOnly() public {
if (msg.sender != address(0x123)) {
revert Unauthorized(msg.sender);
}
}
// Why cheaper? The error selector (4 bytes) replaces a long string,
// saving bytecode size and gas per call.
// ABI decodes arguments so clients get structured data.
}Try / Catch
try/catch gère les erreurs des appels externes seulement — il ne peut pas attraper les reverts d'appels de fonctions internes. La clause 'returns' capture la valeur de succès. catch Error() attrape revert/require avec messages de chaînes ; catch Panic() les paniques assert/overflow ; catch (bytes) est un repli pour erreurs custom et reverts inconnus. À utiliser pour gérer gracieusement les échecs de contrats externes.
contract TryCatch {
interface IToken {
function transfer(address to, uint256 amount) external returns (bool);
}
IToken public token;
constructor(address _token) { token = IToken(_token); }
function safeTransfer(address to, uint256 amount)
public returns (bool success, bool tokenOk)
{
try token.transfer(to, amount) returns (bool ok) {
// Called if no revert; 'ok' captures the return value
return (ok, true);
} catch Error(string memory reason) {
// revert("reason") or require(_, "reason")
// log reason
return (false, false);
} catch Panic(uint256 code) {
// assert failures (code 0x01) or overflow (0x11)
return (false, false);
} catch (bytes memory lowLevelData) {
// Any other revert (including custom errors)
return (false, false);
}
}
// try/catch ONLY works with EXTERNAL calls (or this.f()).
// It does NOT catch errors in internal calls.
// The called function MUST return something (not void).
}Messages et patterns d'erreurs
La gestion d'erreurs moderne utilise des erreurs custom pour des reverts structurés et bon marché. Les vieux messages de chaînes restent courants dans le code antérieur à 0.8.4. Incluez toujours du contexte actionnable : quelle valeur était fausse, quoi attendre. Évitez d'intégrer des adresses/nombres dynamiques dans les messages de chaînes — ils gonflent le bytecode et ne sont pas parsables. Utilisez des messages préfixés ('INVALID:') si vous devez utiliser des chaînes, pour faciliter l'indexation des logs.
contract Errors {
// 1. Custom errors (best for new code)
error InvalidAmount(uint256 given);
error NotOwner(address caller, address owner);
// 2. String errors (older style)
function old(uint256 x) public pure {
require(x > 0, "INVALID: must be > 0"); // prefix helps indexing
require(x < 100, "INVALID: must be < 100");
}
// 3. Custom error with structured data
function newStyle(uint256 x) public pure {
if (x == 0) revert InvalidAmount(x);
}
// 4. Error with multiple fields
address public owner;
constructor() { owner = msg.sender; }
function guarded() public view {
if (msg.sender != owner) {
revert NotOwner(msg.sender, owner);
}
}
// 5. Don't put dynamic data in string errors (expensive & unparseable)
// BAD: require(msg.sender == owner, "not owner: caller 0x123...");
// GOOD: revert NotOwner(msg.sender, owner);
}Héritage
Héritage avec 'is'
L'héritage utilise le mot-clé 'is'. Un contrat enfant hérite de toutes les variables d'état, fonctions et modificateurs de son parent. Les arguments du constructeur parent passent dans la liste d'héritage (Animal("chien")) ou via le style modificateur du constructeur. Un enfant peut surcharger les fonctions marquées virtual dans le parent. Solidity supporte l'héritage multiple (linéarisation via C3).
contract Animal {
string public species;
constructor(string memory _species) {
species = _species;
}
function speak() public virtual returns (string memory) {
return "...";
}
}
contract Dog is Animal {
constructor() Animal("dog") {}
// Override parent function
function speak() public override returns (string memory) {
return "Woof";
}
}
// Multiple inheritance
contract Puppy is Dog {
function speak() public override returns (string memory) {
return "Yip";
}
}Virtual et Override
virtual marque une fonction comme surchargeable ; override comme surchargeant son parent. Les fonctions sont non virtuelles par défaut (plus sûr). En surchargeant depuis plusieurs parents partageant une base, listez-les : override(A, B). Pour permettre d'autres surcharges, utilisez virtual override. Les variables d'état ne peuvent pas être surchargées (seulement masquées en mémoire).
contract Base {
function f() public pure virtual returns (string memory) {
return "base";
}
function g() public pure virtual returns (string memory) {
return "base-g";
}
}
contract Middle is Base {
// Override a single parent
function f() public pure override returns (string memory) {
return "middle";
}
}
contract Multi is Base {
// Override (also virtual so children can override again)
function g() public pure virtual override returns (string memory) {
return "multi";
}
}
contract Combined is Middle, Multi {
// Override multiple parents (explicit list)
function f() public pure override(Middle, Base) returns (string memory) {
return "combined";
}
function g() public pure override(Multi, Base) returns (string memory) {
return "combined-g";
}
}Mot-clé Super
super.methode() appelle la version du parent, permettant d'étendre plutôt que remplacer le comportement. Avec un héritage simple c'est intuitif. Avec héritage multiple, super suit la linéarisation C3 — il peut appeler un contrat frère, pas le parent lexical. Vérifiez toujours l'ordre de linéarisation (le plus dérivé en dernier) quand vous utilisez super dans un héritage en losange.
contract A {
function label() public pure virtual returns (string memory) {
return "A";
}
}
contract B is A {
function label() public pure virtual override returns (string memory) {
return string.concat("B>", super.label()); // calls A.label()
}
}
contract C is B {
function label() public pure override returns (string memory) {
return string.concat("C>", super.label()); // calls B.label()
}
}
// super refers to the NEXT contract in the linearization,
// not necessarily the lexical parent. With multiple inheritance,
// super.label() may call a sibling.
contract P1 { function f() public pure virtual returns (uint) { return 1; } }
contract P2 { function f() public pure virtual returns (uint) { return 2; } }
contract Child is P1, P2 {
function f() public pure override(P1, P2) returns (uint) {
return super.f(); // calls P2.f() (last in linearization)
}
}Héritage multiple
Solidity supporte l'héritage multiple via le mot-clé 'is'. Listez les parents du plus base au plus dérivé : 'is Ownable, Pausable'. L'algorithme de linéarisation C3 produit un ordre déterministe, résolvant le problème du losange. Utilisez 'override(A, B)' pour surcharger une fonction héritée de plusieurs parents. Les constructeurs tournent dans l'ordre de linéarisation (parents d'abord).
contract Ownable {
address public owner;
constructor() { owner = msg.sender; }
modifier onlyOwner() { require(msg.sender == owner); _; }
}
contract Pausable {
bool public paused;
modifier whenNotPaused() { require(!paused); _; }
}
// Multiple inheritance: list parents from most base to most derived
contract Token is Ownable, Pausable {
mapping(address => uint256) public balances;
function mint(address to, uint256 amount)
public
onlyOwner // from Ownable
whenNotPaused // from Pausable
{
balances[to] += amount;
}
}
// C3 Linearization order (for 'Token'):
// Token -> Pausable -> Ownable -> (object)
// Determined by the order in 'is' list (left to right, base first)
//
// Diamond problem is resolved by C3 — there is a single
// deterministic order, no ambiguity. But you must understand it
// when using super.Héritage de constructeur
Les arguments du constructeur parent peuvent passer dans la liste d'héritage (A(42)) pour des valeurs fixes, ou dans le constructeur enfant via la syntaxe modificateur (A(_a)) pour des valeurs d'exécution. Avec plusieurs parents, passez-les dans l'ordre de linéarisation (le plus base d'abord). Si un parent a un constructeur sans argument, on peut l'omettre. Les constructeurs tournent une fois au déploiement, dans l'ordre de linéarisation.
contract A {
uint256 public a;
constructor(uint256 _a) { a = _a; }
}
// Style 1: pass args in inheritance list
contract B1 is A(42) {
// 'a' is set to 42 at deployment
}
// Style 2: pass via modifier-style in child constructor
contract B2 is A {
constructor(uint256 _b) A(_b * 2) {
// 'a' is set to _b * 2
}
}
// Style 3: child has its own constructor + parent args
contract B3 is A {
uint256 public b;
constructor(uint256 _a, uint256 _b) A(_a) {
b = _b;
}
}
// With multiple parents, order = linearization order
contract C1 { constructor(uint) {} }
contract C2 { constructor(uint) {} }
contract C3 is C1, C2 {
constructor(uint x) C1(x) C2(x+1) {}
}Contrats abstraits et interfaces
Contrats abstraits
Un contrat abstrait a au moins une fonction sans corps (déclarée virtual, sans implémentation). Il ne peut pas se déployer directement — un enfant doit implémenter toutes les fonctions abstraites. Utilisez les contrats abstraits pour un état partagé + modificateurs + implémentation partielle. Le mot-clé 'abstract' était obligatoire avant 0.6.0 si une fonction manquait de corps.
abstract contract Ownable {
address public owner;
constructor() { owner = msg.sender; }
modifier onlyOwner() {
require(msg.sender == owner, "not owner");
_;
}
// abstract function — no body, must be implemented by children
function sensitiveAction() public virtual;
// Can have implemented functions too
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
}
contract Vault is Ownable {
function sensitiveAction() public override onlyOwner {
// implementation here
}
}Interfaces
Les interfaces ressemblent à des contrats purement abstraits : pas d'état, pas de constructeurs, pas de fonctions implémentées, toutes les fonctions external. Elles définissent l'ABI d'un contrat pour interagir avec des implémentations inconnues. Utilisez les interfaces pour appeler d'autres contrats sans hériter de leur logique. Préfixez de 'I' (IERC20, IUniswapV2Pair). Les fonctions d'interfaces ne peuvent avoir de modificateurs autre que external view/payable.
interface IERC20 {
// Functions only — no implementation, no state, no constructor
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external view returns (uint256);
function transferFrom(address from, address to, uint256 amount)
external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract MyToken is IERC20 {
// Must implement ALL functions declared in the interface
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
// ... implement the rest
}Virtual vs abstract
abstract = au moins une fonction sans corps ; le contrat ne peut se déployer. virtual = une fonction avec corps que les enfants PEUVENT surcharger. Une fonction peut être les deux (virtual + sans corps). Les interfaces sont implicitement totalement abstraites — chaque fonction est virtual, sans corps et external. Utilisez abstract pour la logique partagée, les interfaces pour de pures définitions d'ABI.
// ABSTRACT contract: has at least one unimplemented function
// Must declare 'abstract'; cannot be deployed directly
abstract contract Counter {
uint256 public count;
function increment() public virtual; // no body -> abstract
function reset() public {
count = 0;
}
}
// VIRTUAL: function HAS a body, but CAN be overridden
contract Base {
function f() public pure virtual returns (uint) {
return 1;
}
}
contract Child is Base {
function f() public pure override returns (uint) {
return 2;
}
}
// A function can be both virtual and abstract (no body)
abstract contract A {
function f() public pure virtual; // virtual + no body
}
// Interfaces are implicitly abstract — all functions virtual+abstract
interface I {
function f() external; // implicit virtual, no body
}Bonnes pratiques des interfaces
Bonnes pratiques : préfixez de 'I', gardez-les minimales (seulement ce dont les appelants ont besoin), toutes les fonctions external, pas d'état/constructeurs/implémentation, événements autorisés. Utilisez les interfaces pour : (1) appeler des contrats dont vous n'avez pas la source, (2) définir des standards (IERC20, IERC721), (3) réduire le bytecode en n'héritant pas d'implémentation. Implémenter une interface force votre contrat à satisfaire le standard.
// 1. Name with 'I' prefix
interface IERC721 {
function ownerOf(uint256 tokenId) external view returns (address);
function transferFrom(address from, address to, uint256 tokenId) external;
}
// 2. Keep minimal — only what callers need
interface IPriceFeed {
function latestAnswer() external view returns (int256);
function decimals() external view returns (uint8);
}
// 3. All functions external (required)
// 4. No state variables, no constructors, no implemented functions
// 5. Events ARE allowed in interfaces
interface IEvents {
event SomethingHappened(uint256 indexed id);
}
// 6. Use to call contracts you don't have source for
contract Consumer {
IPriceFeed public feed;
constructor(address _feed) { feed = IPriceFeed(_feed); }
function price() public view returns (int256) {
return feed.latestAnswer();
}
}
// 7. Implement to satisfy a standard (ERC20, ERC721)
contract MyToken is IERC20 { /* ... */ }Exemple IERC20 (interface)
IERC20 définit le standard de token fongible ERC-20. L'interface déclare les 6 fonctions requises (totalSupply, balanceOf, transfer, approve, allowance, transferFrom) plus les métadonnées optionnelles (name, symbol, decimals) et 2 événements. Tout contrat implémentant cette interface peut être traité comme token ERC-20. Utilisez l'interface pour interagir avec tout ERC-20 sans connaître son implémentation interne.
// Canonical ERC-20 interface
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount)
external returns (bool);
}
// Minimal interaction using the interface
contract Wallet {
IERC20 public token;
constructor(address _token) { token = IERC20(_token); }
function balance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function send(address to, uint256 amount) public returns (bool) {
return token.transfer(to, amount);
}
}Bibliothèques (libraries)
Bases des libraries
Les libraries ressemblent aux contrats mais ne peuvent avoir d'état, hériter ni être héritées. Elles se déploient une fois et se réutilisent via DELEGATECALL (external) ou s'inline (internal). Les fonctions internal de bibliothèque s'inline dans le contrat appelant — pas de déploiement séparé. Utilisez les bibliothèques pour grouper des fonctions réutilisables (maths, validation, formatage). La directive 'using SafeMath for uint256' permet d'appeler les méthodes en a.b().
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "underflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "overflow");
return c;
}
// Libraries CANNOT have state variables
// Libraries CANNOT inherit or be inherited
// All functions must be internal or external
// No constructor, no fallback, no receive
}
contract UsingSafeMath {
using SafeMath for uint256;
function calc(uint256 a, uint256 b) public pure returns (uint256) {
return a.add(b).mul(2); // a.add(b) calls SafeMath.add(a, b)
}
}Using For
'using Library for Type' attache les fonctions de la bibliothèque à ce type, permettant d'appeler valeur.methode() au lieu de Library.methode(valeur). Le premier paramètre de la fonction de bibliothèque doit correspondre au type. La directive marche aussi au niveau fichier (0.8.13+) avec 'using {fn1, fn2} for Type;'. Purement du sucre syntaxique — le compilateur le réécrit en appels directs.
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
// convert uint to decimal string
if (value == 0) return "0";
uint256 temp = value;
uint256 digits;
while (temp != 0) { digits++; temp /= 10; }
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + value % 10));
value /= 10;
}
return string(buffer);
}
}
contract UsingExample {
// Attach library functions to a type
using Strings for uint256;
function describe(uint256 x) public pure returns (string memory) {
// x.toString() calls Strings.toString(x)
return string.concat("Value: ", x.toString());
}
// Attach to a specific type globally (Solidity 0.8.13+)
// using {toString} for uint256; // file-level
// using SafeMath for uint256;
// using SafeMath for *; // not allowed
}Bibliothèques internes
Les fonctions internal de bibliothèque s'inline dans le bytecode du contrat appelant à la compilation — pas de DELEGATECALL à l'exécution, pas de déploiement de bibliothèque, pas d'overhead d'appel. Cela les rend essentiellement gratuites à appeler (juste le gaz des opérations). Utilisez les bibliothèques internes pour des helpers pure/view (maths, conversion de chaînes). La taille du bytecode de l'appelant croît, mais le gaz d'appel est plus bas que les bibliothèques externes.
library Math {
// internal functions are INLINED into the caller's bytecode
// No separate deployment needed — saves gas on each call
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b)
internal pure returns (uint256)
{
// (a + b) / 2 can overflow; this avoids it
return (a & b) + ((a ^ b) / 2);
}
}
contract Calc {
using Math for uint256;
function doMath(uint256 x, uint256 y)
public pure returns (uint256, uint256, uint256)
{
return (x.max(y), x.min(y), x.average(y));
}
}
// Internal libraries are like helper functions that don't add
// runtime call overhead. Good for: math, validation, conversions.Bibliothèques externes (déployées)
Les fonctions external de bibliothèque se déploient comme contrat séparé et s'appellent via DELEGATECALL — elles tournent dans le contexte de l'appelant (stockage, msg.sender). Utile pour du code utilitaire partagé par beaucoup de contrats (économise le gaz de déploiement total). Compromis : overhead DELEGATECALL par appel (~1400 gaz) et la bibliothèque doit être déployée et son adresse liée à la compilation. La plupart des bibliothèques utilisent des fonctions internal ; external est rare.
library BigMath {
// external functions => library is DEPLOYED as a separate contract
// Calls use DELEGATECALL — runs in caller's context (storage/msg)
function complexOperation(uint256[] storage arr)
external view returns (uint256 sum)
{
for (uint256 i = 0; i < arr.length; i++) {
sum += arr[i];
}
}
}
contract UsesExternal {
uint256[] public data;
using BigMath for uint256[];
function total() public view returns (uint256) {
return data.complexOperation(); // DELEGATECALL to BigMath
}
}
// External library trade-offs:
// + Shared bytecode: many contracts use one deployed library (saves deployment gas)
// + Caller bytecode stays small
// - DELEGATECALL overhead per call (~1400 gas)
// - Library must be deployed first and its address linked at compile time
//
// Most libraries are internal; external is rare (e.g., Create2BeaconProxy).Exemple SafeMath (avant 0.8.0)
SafeMath était la bibliothèque canonique de vérification d'overflow avant 0.8.0. Depuis 0.8.0, l'arithmétique annule automatiquement en cas d'overflow, rendant SafeMath inutile pour les maths de base. Elle reste utile pour : (1) lire du code legacy, (2) envelopper explicitement des opérations unchecked, (3) le pattern « require post-condition » comme exemple pédagogique. La version OpenZeppelin reste très référencée.
// Before 0.8.0, arithmetic did NOT auto-check overflow.
// SafeMath was essential. Now it's mostly historical,
// but the pattern is instructive and still useful for
// explicit intent.
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage)
internal pure returns (uint256)
{
require(b <= a, errorMessage);
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage)
internal pure returns (uint256)
{
require(b > 0, errorMessage);
return a / b;
}
}Transferts d'Ether
Payable et msg.value
Les fonctions payable acceptent des Ether via msg.value (en wei). Les Ether s'ajoutent automatiquement au solde du contrat — pas besoin de les suivre manuellement sauf comptabilité par utilisateur. Validez msg.value pour des paiements exacts ou minimaux. Remboursez toujours l'Ether excédentaire pour éviter de le bloquer dans le contrat. 1 ether = 10^18 wei.
contract PayableContract {
address payable public owner;
constructor() {
owner = payable(msg.sender);
}
// payable = function accepts Ether
function deposit() public payable {
// msg.value = wei sent with this call
// Ether auto-added to address(this).balance
// No need to update a balance variable here
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
// Specify required payment
function buyItem() public payable {
require(msg.value == 1 ether, "must pay 1 ether");
// process purchase
}
// Send excess back
function refundExcess(uint256 price) public payable {
uint256 excess = msg.value - price;
if (excess > 0) {
(bool ok, ) = msg.sender.call{value: excess}("");
require(ok, "refund failed");
}
}
}Transfer
address.transfer(montant) envoie des Ether et annule en cas d'échec. Il transmet une dotation fixe de 2300 gaz, qui historiquement prévenait la réentrance mais est aujourd'hui jugé fragile (coûts de gaz changés à Istanbul 2019). Recommandation moderne : utilisez transfer seulement vers une adresse de confiance (comme owner). Pour des destinataires arbitraires, utilisez .call{value:} avec des gardes de réentrance explicites, car la dotation de 2300 peut être insuffisante pour une logique receive/fallback légitime.
contract TransferExample {
address payable public recipient = payable(0xAbC...);
function sendViaTransfer() public payable {
// transfer: throws on failure, forwards 2300 gas stipend
// Simple and safe against reentrancy (limited gas)
recipient.transfer(1 ether);
}
function sendFromContract() public {
// address(this).balance = current contract balance
recipient.transfer(address(this).balance);
}
// Characteristics:
// - Reverts if recipient's receive/fallback uses > 2300 gas
// - 2300 gas stipend: enough for an event log, not a storage write
// - Safer than send (which returns false on failure)
// - But BEWARE: post-Istanbul (2019), some operations cost more,
// breaking contracts that relied on 2300 gas. Prefer .call{}.
}
// transfer is DEPRECATED for pushing to arbitrary addresses.
// Use .call{value:} and handle the return value.Send
address.send(montant) retourne un booléen (true en succès, false en échec) — il n'annule PAS automatiquement. Vous DEVEZ vérifier la valeur de retour et annuler en cas d'échec. Comme transfer, il ne transmet que 2300 gaz. send est error-prone (les développeurs oublient de vérifier) et rarement utilisé dans le code moderne. Préférez .call{value:} pour les nouveaux contrats.
contract SendExample {
address payable public recipient = payable(0xAbC...);
function sendViaSend() public payable returns (bool) {
// send: returns false on failure (does NOT revert)
// Also forwards 2300 gas stipend like transfer
bool success = recipient.send(1 ether);
require(success, "send failed"); // you MUST check the return value
return success;
}
// Common bug: forgetting to check the return value
function buggy() public payable {
recipient.send(1 ether); // BUG: silently fails
// state already updated => funds lost
}
// Correct: check + revert
function correct() public payable {
bool ok = recipient.send(1 ether);
require(ok, "send failed");
}
}
// send is rarely used in modern code.
// Prefer .call{value:} which gives more control + return data.Call (recommandé)
.call{value: x}(...) est la façon recommandée d'envoyer des Ether depuis 0.8.0. Il transmet tout le gaz disponible (selon la règle 63/64), permettant aux destinataires une logique complexe. Il retourne (bool, bytes) — vous DEVEZ vérifier le booléen et annuler en cas d'échec. Comme il transmet tout le gaz, il est vulnérable à la réentrance — associez toujours un modificateur nonReentrant ou suivez checks-effects-interactions. Utilisez call pour des destinataires arbitraires ; transfer seulement pour des adresses de confiance.
contract CallExample {
address payable public recipient = payable(0xAbC...);
function sendViaCall() public payable returns (bool) {
// .call returns (bool success, bytes memory data)
// Forwards ALL gas (63/64 rule), so recipient can do more
(bool success, ) = recipient.call{value: 1 ether}("");
require(success, "call failed");
return success;
}
// With calldata (call a function while sending Ether)
function callWithFunction(address token, address to, uint256 amount)
public returns (bool, bytes memory)
{
(bool ok, bytes memory data) = token.call{value: 0}(
abi.encodeWithSignature("transfer(address,uint256)", to, amount)
);
return (ok, data);
}
// Forward gas explicitly
function withGas() public returns (bool) {
(bool ok, ) = recipient.call{gas: 100000, value: 0}("");
return ok;
}
// IMPORTANT: call forwards all gas, so a malicious recipient
// can re-enter your contract. Always use a reentrancy guard.
}Vérification de solde
address.balance retourne le solde en wei de n'importe quelle adresse (y compris address(this) pour le contrat lui-même). C'est un view, gratuit hors chaîne. ATTENTION : le solde peut être gonflé par n'importe qui via selfdestruct (Ether forcés), donc ne vous fiez jamais à une égalité exacte de solde pour la logique — utilisez >= ou maintenez vos propres variables de comptabilité. Vérifiez toujours que la somme des dépôts égale le solde du contrat comme invariant.
contract BalanceCheck {
mapping(address => uint256) public deposits;
function deposit() public payable {
deposits[msg.sender] += msg.value;
}
function contractBalance() public view returns (uint256) {
// Balance of THIS contract
return address(this).balance;
}
function userBalance(address user) public view returns (uint256) {
// Balance of any address (in wei)
return user.balance;
}
function myBalance() public view returns (uint256) {
return msg.sender.balance;
}
// Verify accounting invariant
function verify() public view returns (bool) {
// Sum of deposits should equal contract balance
// (in a real contract, this would be expensive to compute)
return address(this).balance >= deposits[msg.sender];
}
// CAUTION: address.balance can be manipulated by an attacker
// who forces Ether via selfdestruct. Never use balance == X
// as a strict equality check for logic — use >= or tracking vars.
function dangerous() public view returns (bool) {
// BAD: an attacker can selfdestruct-ETH into the contract
// and break this exact check
return address(this).balance == 1 ether;
}
}Optimisation du gaz
Storage vs memory
Les lectures de stockage (SLOAD) coûtent ~2100 gaz froid / 100 chaud par accès. Les lectures mémoire (MLOAD) ne coûtent que 3 gaz. Quand une fonction lit plusieurs fois une variable d'état (surtout dans une boucle), mettez-la d'abord en cache dans une variable memory. Le premier SLOAD est cher ; les lectures mémoire suivantes sont quasi gratuites. L'une des optimisations les plus simples et les plus impactantes.
contract StorageVsMemory {
uint256 public stateVar; // storage slot 0
function expensive(uint256 x) public view returns (uint256) {
// Each access to stateVar = SLOAD (~2100 gas cold, 100 warm)
uint256 sum = 0;
for (uint256 i = 0; i < x; i++) {
sum += stateVar; // SLOAD every iteration
}
return sum;
}
function cheap(uint256 x) public view returns (uint256) {
// Cache to memory once: MLOAD costs 3 gas
uint256 cached = stateVar; // 1 SLOAD
uint256 sum = 0;
for (uint256 i = 0; i < x; i++) {
sum += cached; // MLOAD (cheap)
}
return sum;
}
// Rules of thumb:
// - storage: persistent, ~2100 gas per cold SLOAD, ~5000-20000 per SSTORE
// - memory: temporary, ~3 gas per access, free to create
// - calldata: read-only, free (passed in)
// Always cache state variables used multiple times in a function.
}Packing de variables
Solidity packe les variables d'état consécutives en slots de stockage de 32 octets. Pour économiser le gaz, groupez les petits types (uint8, uint64, address) ensemble pour qu'ils partagent un slot. Réordonnez les champs de struct pour que les petits packent serrés. Chaque slot économisé = ~20k gaz au premier accès. Note : les entrées de mapping et de tableau dynamique commencent toujours un nouveau slot et ne peuvent pas être packées.
contract Packing {
// BAD: each takes a full 32-byte slot
// 3 slots = 60k gas for cold SLOADs
struct Bad {
uint64 time;
address from; // 20 bytes
uint64 amount;
}
// GOOD: pack small types together into 32 bytes
// 1 slot = 20k gas (one SLOAD)
struct Good {
uint64 time;
uint64 amount;
address from; // 20 bytes => total 8+8+20 = 36... still 2 slots
}
// Pack carefully: declare small types together
struct Packed {
uint32 a; // 4
uint32 b; // 4
uint32 c; // 4
uint32 d; // 4 => 16 bytes => can fit address (20)? No, 16+20=36 > 32
address e; // => 2 slots
}
struct Tight {
uint128 a; // 16
uint128 b; // 16 => 1 slot (32 bytes)
}
// Order matters: variables are packed in declaration order.
// A variable that doesn't fit starts a new slot.
// Mapping/dynamic-array always start a new slot.Blocs unchecked
unchecked { ... } désactive les vérifications d'overflow/underflow dans le bloc, économisant du gaz (~50-80 par op). Sûr quand vous avez déjà validé les bornes (ex. après require(a >= b), a - b ne peut pas sous-fluer). Le cas d'usage sûr classique est les compteurs de boucle (i++ dans un for ne débordera jamais 2^256). N'utilisez pas unchecked aveuglément — l'overflow silencieux est un risque de sécurité.
contract UncheckedBlock {
function loopWith(uint256 n) public pure returns (uint256 sum) {
// 0.8+ checks overflow on every operation (extra gas)
for (uint256 i = 0; i < n; i++) {
sum += i;
}
}
function loopUnchecked(uint256 n) public pure returns (uint256 sum) {
unchecked {
for (uint256 i = 0; i < n; i++) {
sum += i; // skips overflow check (cheaper)
}
}
}
// Safe to use when overflow is impossible:
// - Loop counters that won't reach 2^256
// - Differences of values you've already bounds-checked
function safeSub(uint256 a, uint256 b) public pure returns (uint256) {
require(a >= b, "underflow"); // checked here
unchecked { return a - b; } // safe: can't underflow now
}
// NEVER use unchecked when overflow/underflow is possible
// unless you intentionally want wraparound (rare).
}Erreurs custom vs require
Les erreurs custom (0.8.4+) sont moins chères que require(_, "msg") car la chaîne de message se stocke dans le bytecode (coûtant du gaz par octet) et se ré-encode à chaque revert. Une erreur custom n'est qu'un sélecteur de 4 octets plus des args ABI. Pour des messages d'erreur non triviaux, les erreurs custom économisent des milliers de gaz par appel ET réduisent la taille du bytecode de déploiement. Préférez toujours les erreurs custom dans le nouveau code.
contract Errors {
// BAD: string messages bloat bytecode + cost gas per call
function oldStyle(uint256 x) public pure {
require(x > 0, "value must be greater than zero");
require(x < 100, "value must be less than one hundred");
}
// GOOD: custom errors are cheap and structured
error InvalidValue(uint256 given, uint256 min, uint256 max);
function newStyle(uint256 x) public pure {
if (x == 0 || x >= 100) {
revert InvalidValue(x, 1, 99);
}
}
// Gas comparison (approximate):
// require(_, "msg") ~ 400 + 50 per byte of message
// revert CustomError() ~ 400 + small selector cost
//
// For long messages, custom errors save thousands of gas
// and reduce deployed bytecode size.
// Define errors at file level to reuse across contracts
error Unauthorized(address caller);
function guarded() public {
if (msg.sender != address(0)) revert Unauthorized(msg.sender);
}
}Cacher les variables d'état dans les boucles
Cachez la longueur du tableau dans une variable locale avant la boucle (économise un SLOAD par itération). Si le tableau est petit, copiez-le en memory une fois (un SLOAD par élément, puis des MLOAD bon marché dans la boucle). Les accumulateurs doivent toujours être locaux (memory). Pour les champs de struct en stockage, cachez tout le struct en memory si utilisé plusieurs fois.
contract Cache {
uint256[] public data;
mapping(address => uint256) public balances;
address[] public users;
// BAD: reads mapping in every iteration (SLOAD each time)
function sumBad() public view returns (uint256) {
uint256 total = 0;
for (uint256 i = 0; i < users.length; i++) {
total += balances[users[i]]; // SLOAD each iteration
}
return total;
}
// GOOD: cache length, use local var for accumulator
function sumBetter() public view returns (uint256) {
uint256 total = 0;
uint256 len = users.length; // cache length
for (uint256 i = 0; i < len; i++) {
address u = users[i]; // SLOAD once
total += balances[u]; // still SLOAD, but unavoidable
}
return total;
}
// BEST: cache array to memory (if small enough)
function sumMemory() public view returns (uint256) {
address[] memory memUsers = users; // copy to memory once
uint256 total = 0;
uint256 len = memUsers.length;
for (uint256 i = 0; i < len; i++) {
total += balances[memUsers[i]]; // MLOAD each iteration
}
return total;
}
}Court-circuit et optimisation de boucles
Évaluation en court-circuit : mettez d'abord les vérifications bon marché dans && et ||. Utilisez ++i (préfixe) au lieu de i++ (légèrement moins cher — pas de temporaire). Enveloppez les compteurs de boucle dans unchecked (i ne débordera pas de façon réaliste 2^256). Sortez tôt des boucles quand vous trouvez ce que vous cherchez. Évitez les opérations coûteuses (appels externes, écritures de stockage) dans les boucles — batchez-les à l'extérieur.
contract ShortCircuit {
// && and || short-circuit: right side only evaluated if needed
function cheap(address a, address b) public view returns (bool) {
// Put the cheap check first
return (a == b || expensiveCheck(a));
}
function expensiveCheck(address) internal view returns (bool) {
// imagine a heavy computation
return true;
}
// Loop optimization: prefer prefix increment
function good() public pure returns (uint256) {
uint256 sum = 0;
for (uint256 i = 0; i < 10; ++i) { // ++i slightly cheaper than i++
sum += i;
}
return sum;
}
// Use unchecked for loop counters (always safe)
function best() public pure returns (uint256) {
uint256 sum = 0;
uint256 i = 0;
unchecked {
while (i < 10) {
sum += i;
++i;
}
}
return sum;
}
// Avoid unnecessary work: precompute, batch, early-exit
function find(uint256[] memory arr, uint256 target)
public pure returns (int256)
{
for (uint256 i = 0; i < arr.length; ++i) {
if (arr[i] == target) return int256(i); // early exit
}
return -1;
}
}Unités de temps et propriétés de bloc
block.timestamp
block.timestamp (alias 'now' avant 0.7.0) est le timestamp Unix du bloc courant en secondes. Réglé par le mineur/validateur, manipulable d'environ 15 secondes — NE l'utilisez JAMAIS pour l'aléatoire ou un timing précis. Acceptable pour des durées grossières (>= 1 minute) et l'ordre. Usages courants : time-locks, plannings de vesting, échéances. Utilisez block.number pour des garanties plus strictes.
contract Time {
uint256 public startTime;
uint256 public constant DURATION = 1 days;
constructor() {
startTime = block.timestamp; // uint256 in 0.8+
}
function isExpired() public view returns (bool) {
return block.timestamp >= startTime + DURATION;
}
function elapsed() public view returns (uint256) {
return block.timestamp - startTime;
}
// WARNING: block.timestamp is set by the miner/validator.
// They can manipulate it by ~15 seconds. NEVER use it for:
// - Randomness (keccak256(block.timestamp) is exploitable)
// - Precise timing (use block.number as a fallback)
// It's fine for:
// - Coarse durations (>= 1 minute)
// - Deadlines that tolerate 15s drift
// - Order of events (timestamp comparison)
// Time locks: require(block.timestamp > unlockTime)
function lock() public payable returns (uint256) {
return block.timestamp + 1 weeks;
}
}block.number et blockhash
block.number est la hauteur du bloc courant. blockhash(n) retourne le hash du bloc n, mais SEULEMENT pour les 256 derniers blocs (plus vieux retourne 0) et pas le bloc courant (retourne 0). block.number et blockhash peuvent être influencés par les mineurs, donc ne les utilisez pas pour un aléatoire à fort enjeu. Pour un vrai aléatoire, utilisez Chainlink VRF ou un schéma commit-reveal avec entropie fournie par l'utilisateur.
contract BlockInfo {
function currentBlock() public view returns (uint256) {
return block.number;
}
function prevHash(uint256 n) public view returns (bytes32) {
// Only the last 256 blocks' hashes are available
require(n > 0 && n <= 256, "out of range");
return blockhash(block.number - n);
}
// blockhash returns 0 for current block, future blocks, or >256 old
function currentHash() public view returns (bytes32) {
return blockhash(block.number); // returns 0!
}
// Use case: weak randomness (still exploitable by miners)
function pseudoRandom() public view returns (uint256) {
// A miner CAN see this and choose to withhold blocks
// to manipulate the result. Don't use for high value.
return uint256(keccak256(abi.encodePacked(
blockhash(block.number - 1),
block.timestamp,
msg.sender
)));
}
// For real randomness, use Chainlink VRF or a commit-reveal scheme.
}Unités de temps (seconds/minutes/hours/days/weeks)
Les suffixes d'unités de temps (seconds, minutes, hours, days, weeks) convertissent en secondes en uint256. 'years' a été retiré en 0.5.0 à cause de l'ambiguïté des années bissextiles. Les unités d'Ether (wei, gwei, ether) sont séparées : 1 ether = 10^18 wei, 1 gwei = 10^9 wei. Stockez toujours les montants en wei et utilisez les suffixes pour la lisibilité dans les calculs.
contract TimeUnits {
// Suffixes convert to seconds (uint256):
uint256 public oneSecond = 1 seconds; // 1
uint256 public oneMinute = 1 minutes; // 60
uint256 public oneHour = 1 hours; // 3600
uint256 public oneDay = 1 days; // 86400
uint256 public oneWeek = 1 weeks; // 604800
// 'years' was removed in 0.5.0 (leap years made it ambiguous)
function deadline() public view returns (uint256) {
return block.timestamp + 7 days;
}
function hourly() public pure returns (uint256) {
return 24 hours; // 86400
}
// Ether units (different from time units!):
uint256 public oneWei = 1 wei; // 1
uint256 public oneGwei = 1 gwei; // 10^9
uint256 public oneEther = 1 ether; // 10^18
function fromEther(uint256 e) public pure returns (uint256) {
return e * 1 ether; // convert to wei
}
function toEther(uint256 weiAmount) public pure returns (uint256) {
return weiAmount / 1 ether;
}
}Gaz et gasleft()
gasleft() retourne le gaz restant au point d'appel (remplace le msg.gas déprécié). Utile pour mesurer combien de gaz un morceau de code consomme. La règle des 63/64e : les appels externes transmettent 63/64 du gaz restant, gardant 1/64 de réserve pour que l'appelant gère le retour. Ne vous fiez pas aux valeurs de gaz exactes entre hard forks — les coûts d'opcodes changent.
contract GasTrack {
function checkGas() public returns (uint256, uint256) {
uint256 start = gasleft(); // gas remaining at this point
// ...do some work...
uint256 sum = 0;
for (uint256 i = 0; i < 100; i++) {
sum += i;
}
uint256 end = gasleft();
return (start, start - end); // (initial, used)
}
// 63/64th rule: when an external call is made, only 63/64 of
// remaining gas is forwarded; 1/64 is reserved so the caller
// can finish processing (e.g., revert handling).
function forwardGas(address target) public returns (bool, uint256) {
uint256 before = gasleft();
(bool ok, ) = target.call{gas: 100000}("");
uint256 after = gasleft();
return (ok, before - after);
}
// gasleft() replaces the deprecated msg.gas.
// It's a view, so it can be used in modifiers to enforce budgets.
modifier usesLessThan(uint256 maxGas) {
uint256 start = gasleft();
_;
require(start - gasleft() <= maxGas, "too much gas");
}
}Chain ID et détection de réseau
block.chainid retourne l'ID de chaîne courant. Essentiel pour la protection de rejeu (EIP-155) et les signatures de données typées EIP-712 (le domain separator inclut chainId). Cachez chainId en immutable dans le constructeur pour l'efficacité de gaz, mais pour EIP-712 il peut falloir recalculer si le contrat est forké vers une nouvelle chaîne. Incluez toujours chainId dans tout hash signant une autorisation.
contract Chain {
function getChainId() public view returns (uint256) {
return block.chainid; // current chain ID
}
// Common chain IDs:
// 1 = Ethereum mainnet
// 5 = Goerli testnet (deprecated)
// 11155111 = Sepolia testnet
// 137 = Polygon
// 42161 = Arbitrum One
// 10 = Optimism
// 56 = BNB Smart Chain
modifier onlyMainnet() {
require(block.chainid == 1, "only mainnet");
_;
}
// Prevent cross-chain replay attacks by including chainId in hashes
function domainSeparator() public view returns (bytes32) {
return keccak256(abi.encode(
keccak256("EIP712Domain(...)"),
block.chainid,
address(this)
));
}
// For multi-chain deployments, store chainId at construction
uint256 public immutable chainId;
constructor() {
chainId = block.chainid;
}
// NOTE: chainId can change during a fork (rare). For EIP-712
// signatures, cache it but allow re-initialization on mismatch.
}Modificateurs de visibilité
Public
Les fonctions public peuvent être appelées de partout : en externe (par utilisateurs ou autres contrats), en interne (depuis le contrat) et depuis les contrats dérivés. Les variables d'état publiques obtiennent automatiquement une fonction getter. Public est la plus permissive mais ajoute du bytecode (la fonction doit supporter les conventions d'appel interne et externe). Quand une fonction public est appelée en interne via 'this.f()', elle devient un appel externe coûteux.
contract Public {
uint256 public counter; // public state var => auto getter
// public function: callable from anywhere
// - externally (via transaction or call)
// - internally (from this contract)
// - from derived contracts
function increment() public {
counter += 1;
}
function caller() public {
increment(); // internal call (cheap)
this.increment(); // external call (expensive, creates a msg)
}
// Public is the most permissive. Auto-getters for state vars
// are 'external' view functions generated by the compiler.
//
// Cost: public functions are part of the ABI and add bytecode.
// Internal calls to public functions skip the external wrapper.
}External
Les fonctions external ne peuvent être appelées QUE de l'extérieur du contrat — pas en interne. Légèrement moins chères que public car elles lisent directement depuis le calldata (pas de copie mémoire). Utilisez external pour les fonctions qui ne devraient être que des points d'entrée. Si vous devez appeler une fonction en interne et en externe, faites-la public OU séparez-la en un wrapper external + une impl internal.
contract External {
// external: ONLY callable from outside the contract
// CANNOT be called internally (this.f() works but is expensive)
function doWork(uint256 x) external pure returns (uint256) {
return x * 2;
}
function caller() public pure returns (uint256) {
// doWork(5); // COMPILER ERROR: external not callable internally
return this.doWork(5); // works but creates an external call (expensive)
}
// external with calldata params is cheapest for inputs
function process(string calldata input)
external
pure
returns (bytes32)
{
return keccak256(bytes(input));
}
// Use external when:
// - The function is only meant to be called by users/other contracts
// - You want to read calldata directly (cheaper than memory)
//
// State variables CANNOT be external.
}Internal
Les fonctions internal peuvent être appelées depuis le contrat et tout contrat dérivé (sous-classes). C'est le défaut des variables d'état. internal est moins cher que public car il n'exige pas l'enveloppe d'appel externe. Utilisez internal pour les fonctions utilitaires et la logique cœur que les sous-classes doivent pouvoir appeler ou surcharger. La convention est de préfixer les fonctions internes d'un underscore (_helper).
contract Internal {
uint256 internal secret; // internal state var (default)
// internal: callable from this contract AND derived contracts
function _helper(uint256 x) internal pure returns (uint256) {
return x + 1;
}
function caller() public pure returns (uint256) {
return _helper(5); // internal call works
}
// Cannot be called externally:
// contract Other { function f() public { Internal._helper(5); } } // ERROR
}
contract Child is Internal {
function useParent() public pure returns (uint256) {
return _helper(10); // OK: child can call internal
}
function readSecret() public view returns (uint256) {
return secret; // OK: child can read internal
}
}
// internal is the DEFAULT for state variables.
// Use internal when:
// - You want subclasses to use/override it
// - You don't need external access
// It's cheaper than public (no external wrapper).Private
Les fonctions et variables d'état private ne sont accessibles que dans le contrat définissant — pas même aux sous-classes. La visibilité la plus restreinte. CRUCIAL : 'private' ne signifie PAS secret — toutes les données blockchain sont publiquement lisibles via eth_getStorageAt et l'analyse du bytecode. Utilisez private seulement pour empêcher d'autres contrats d'appeler/hériter ; utilisez chiffrement/hachage pour la vraie confidentialité.
contract Private {
uint256 private counter; // private state var
// private: ONLY callable from THIS contract (not even subclasses)
function _secret(uint256 x) private pure returns (uint256) {
return x * 42;
}
function caller() public pure returns (uint256) {
return _secret(5); // OK: same contract
}
}
contract Sub is Private {
// function useIt() public pure returns (uint256) {
// return _secret(5); // COMPILER ERROR: not accessible
// }
// function readCounter() public view returns (uint256) {
// return counter; // COMPILER ERROR: not accessible
// }
}
// IMPORTANT: 'private' does NOT mean hidden on-chain.
// All storage and bytecode are publicly readable via RPC.
// 'private' only means 'not part of the contract's ABI'
// and 'not callable/inheritable by other contracts'.
// For real confidentiality, use encryption or zero-knowledge proofs.Bonnes pratiques de visibilité
Bonnes pratiques : utilisez la visibilité la plus restreinte qui marche (private > internal > external > public). Évitez les variables d'état publiques sauf si vous voulez l'auto-getter — des getters explicites permettent d'ajouter de la validation plus tard. Utilisez external+calldata pour les points d'entrée. Préfixez les helpers internal/private d'un underscore. Chaque fonction public/external ajoute du bytecode ; minimiser l'ABI réduit le gaz de déploiement et d'appel.
contract Best {
// 1. Default to the MOST restrictive visibility that works.
// Order: private < internal < external < public
// 2. State variables: NEVER public unless you want a free getter.
// Prefer private/internal + explicit getter functions,
// so you can add validation/logic later.
uint256 private _balance;
function balance() public view returns (uint256) {
return _balance;
}
// 3. External functions: use 'external' + 'calldata' for entry points
function buy(uint256[] calldata ids) external payable {
for (uint256 i = 0; i < ids.length; i++) {
_buyOne(ids[i]);
}
}
// 4. Internal helper: prefix with underscore convention
function _buyOne(uint256 id) internal {
// ...
}
// 5. Private for truly internal-only logic
function _computeFee(uint256 amount) private pure returns (uint256) {
return amount / 100;
}
// 6. Avoid public functions that are never called externally
// (wastes bytecode). Make them internal.
}
// Summary: visibility is part of the contract's API design.
// Smaller ABI = less bytecode = lower deployment + call gas.Interaction entre contrats
Appeler d'autres contrats
Pour appeler un autre contrat, castez son adresse vers un type d'interface : IToken(addr).methode(). Les appels view sont gratuits hors chaîne mais coûtent du gaz depuis une transaction. Vérifiez toujours les valeurs de retour des appels modifiant l'état (token.transfer retourne un bool). Caster une adresse en interface ne vérifie PAS que le contrat l'implémente réellement — si la fonction n'existe pas, l'appel annule.
interface IToken {
function balanceOf(address) external view returns (uint256);
function transfer(address, uint256) external returns (bool);
}
contract Caller {
IToken public token;
address public owner;
constructor(address _token) {
token = IToken(_token);
owner = msg.sender;
}
// Call a view function on another contract
function getBalance(address who) public view returns (uint256) {
return token.balanceOf(who); // external call
}
// Call a state-changing function
function sendTokens(address to, uint256 amount)
public returns (bool)
{
require(msg.sender == owner, "not owner");
bool ok = token.transfer(to, amount);
require(ok, "transfer failed");
return true;
}
// Cast any address to an interface (no validation!)
function checkAny(address maybeToken)
public view returns (uint256)
{
return IToken(maybeToken).balanceOf(address(this));
}
}Appels par interface
Utilisez les interfaces pour interagir avec tout contrat dont vous connaissez l'ABI, sans sa source. Cela découple les appelants des implémentations et marche avec tout token/protocole suivant un standard (ERC20, ERC721, flux Chainlink). Les interfaces gardent votre bytecode petit (pas de logique héritée) et permettent du code générique (un wallet qui marche avec tout ERC20). Préférez toujours les interfaces aux contrats concrets pour les appels externes.
interface IERC20 {
function name() external view returns (string memory);
function balanceOf(address) external view returns (uint256);
function transfer(address, uint256) external returns (bool);
}
contract Wallet {
IERC20 public immutable token;
address public owner;
constructor(address _token) {
token = IERC20(_token);
owner = msg.sender;
}
function tokenBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function withdraw(uint256 amount) public {
require(msg.sender == owner, "not owner");
token.transfer(owner, amount);
}
function tokenName() public view returns (string memory) {
return token.name();
}
}
// Why use interfaces?
// - Decouple: Wallet doesn't need to know token implementation
// - Reusability: works with ANY ERC20 (USDC, DAI, WETH, ...)
// - Smaller bytecode: don't inherit the token's code
// - Standardization: IERC20 is a documented ABIAppel bas niveau
address.call(payload) est l'appel le plus bas niveau, retournant (bool, bytes). À utiliser quand vous n'avez pas d'interface, voulez transmettre un calldata arbitraire, ou avez besoin d'un contrôle fin (gaz, valeur). Bâtissez le calldata avec abi.encodeWithSignature/Selector/Call. CRUCIAL : 'ok' est false seulement sur des échecs EVM (revert, manque de gaz), pas sur des échecs logiques — décodez 'data' pour inspecter les raisons de revert ou erreurs custom.
contract LowLevel {
// call: lowest-level call, returns (bool, bytes)
function callFn(address target, bytes memory payload)
public returns (bool, bytes memory)
{
(bool ok, bytes memory data) = target.call(payload);
require(ok, "call failed");
return (ok, data);
}
// With Ether
function callWithEth(address target, bytes memory payload)
public payable returns (bool, bytes memory)
{
(bool ok, bytes memory data) = target.call{value: msg.value}(payload);
return (ok, data);
}
// With gas limit
function callWithGas(address target, bytes memory payload, uint256 gas)
public returns (bool, bytes memory)
{
return target.call{gas: gas}(payload);
}
// Helpers to build calldata:
// abi.encodeWithSignature("transfer(address,uint256)", to, amount)
// abi.encodeWithSelector(bytes4(selector), to, amount)
// abi.encodeWithCall(IERC20.transfer.selector, to, amount)
// WARNING: low-level call returns true even if the called function
// reverts internally — you only get false on EVM-level failure.
// Decode 'data' to inspect custom errors or return values.
function safeCall(address target) public returns (uint256) {
(bool ok, bytes memory data) = target.call(
abi.encodeWithSignature("getValue()")
);
require(ok, "call reverted");
return abi.decode(data, (uint256));
}
}Delegatecall
delegatecall exécute le code de la cible dans le contexte de stockage de l'APPELANT — les changements d'état affectent l'appelant, pas la cible. msg.sender et msg.value se préservent. C'est le socle des proxys upgradables (EIP-1967, UUPS) et du pattern Diamond (EIP-2535). CRUCIAL : la disposition de stockage doit correspondre entre appelant et cible, sinon l'état se corrompt. Utilisez toujours une disposition de stockage partagée ou le pattern AppStorage.
contract Delegate {
// delegatecall: executes target's code in CALLER's context
// - msg.sender is the ORIGINAL caller (preserved)
// - msg.value is preserved
// - Storage reads/writes affect the CALLER, not the target
// - address(this) is the CALLER
uint256 public num;
address public sender;
function delegateSet(address target, uint256 value) public {
// target's setNum() runs in THIS contract's storage
(bool ok, ) = target.delegatecall(
abi.encodeWithSignature("setNum(uint256)", value)
);
require(ok, "delegatecall failed");
}
}
contract Target {
// MUST have the same storage layout as Delegate for sane behavior!
uint256 public num;
address public sender;
function setNum(uint256 value) public {
num = value;
sender = msg.sender; // this is the ORIGINAL caller, not Delegate
}
}
// Use cases:
// - Proxy patterns (EIP-1967, UUPS, Transparent): upgradeable logic
// - Diamond pattern (EIP-2535): modular facets
//
// DANGER: storage layout mismatch => corrupted state.
// Both contracts MUST declare variables in the same order/types.
// Use a shared storage contract or app storage pattern.Staticcall
staticcall exécute le code de la cible mais annule si une modification d'état survient — la façon sûre de lire depuis des contrats non fiables. Le compilateur utilise automatiquement staticcall quand vous appelez une fonction view/pure via une interface. Utilisez staticcall directement quand vous voulez garantir une lecture seule vers un contrat qui pourrait mentir sur son caractère view. Il retourne (bool, bytes) comme call.
contract Static {
// staticcall: like call, but REVERTS if the target modifies state.
// Used to safely READ from untrusted contracts.
function safeRead(address target, bytes memory payload)
public view returns (bytes memory)
{
(bool ok, bytes memory data) = target.staticcall(payload);
require(ok, "staticcall reverted");
return data;
}
function getBalance(address token, address who)
public view returns (uint256)
{
(bool ok, bytes memory data) = token.staticcall(
abi.encodeWithSignature("balanceOf(address)", who)
);
require(ok, "balanceOf failed");
return abi.decode(data, (uint256));
}
// Use cases:
// - Read from untrusted contracts without risk of state changes
// - Verify a contract behaves as a view function
// - Compose view-only queries across multiple contracts
// Distinguish from call():
// - call: allows state changes (target can write)
// - staticcall: forbids state changes (reverts if target writes)
// view/pure functions are called via staticcall automatically
// by the compiler when you call them normally.
function normalCall(IToken t, address who) public view returns (uint256) {
return t.balanceOf(who); // compiler emits staticcall
}
}
interface IToken { function balanceOf(address) external view returns (uint256); }Patterns de sécurité
Garde de réentrance
La garde de réentrance est un mutex empêchant une fonction d'être ré-entrée pendant son exécution. Posez un flag avant le corps, levez-le après. Cela prévient l'attaque classique où le receive/fallback d'un contrat malveillant rappelle withdraw() avant que le solde soit remis à zéro (le pattern du hack DAO). Appliquez nonReentrant à toute fonction qui fait un appel externe après un changement d'état — même si vous suivez aussi checks-effects-interactions (défense en profondeur).
contract ReentrancyGuard {
// Classic mutex pattern using a storage flag
uint256 private _status = 1; // 1 = NOT_ENTERED, 2 = ENTERED
modifier nonReentrant() {
require(_status == 1, "REENTRANT");
_status = 2;
_;
_status = 1;
}
mapping(address => uint256) public balances;
function withdraw() public nonReentrant {
uint256 amount = balances[msg.sender];
require(amount > 0, "no balance");
// CRITICAL: update state BEFORE the external call
balances[msg.sender] = 0;
(bool ok, ) = msg.sender.call{value: amount}("");
require(ok, "send failed");
}
// Why needed: if we sent Ether FIRST, the attacker's receive()
// could call withdraw() again before balances was zeroed,
// draining the contract. This is the DAO hack pattern.
//
// Even with checks-effects-interactions, the guard is defense-in-depth.
// Apply nonReentrant to ANY function that:
// - Sends Ether to msg.sender
// - Calls an external contract
// - Then continues executing
}Checks-Effects-Interactions
Checks-Effects-Interactions (CEI) est le pattern de sécurité le plus important : (1) exécutez toutes les vérifications require/validate, (2) mettez à jour toutes les variables d'état, (3) ENSUITE faites les appels externes. Si un appel externe ré-entre dans votre contrat, l'état est déjà mis à jour, donc l'attaquant ne peut pas dépenser deux fois. CEI seul prévient la plupart des bugs de réentrance ; associez un modificateur nonReentrant pour la défense en profondeur sur les fonctions critiques.
contract CEI {
mapping(address => uint256) public balances;
// BAD: interaction BEFORE effect => reentrancy vulnerability
function vulnerable() public {
uint256 amount = balances[msg.sender];
(bool ok, ) = msg.sender.call{value: amount}(""); // INTERACTION
require(ok);
balances[msg.sender] = 0; // EFFECT (too late!)
// Attacker's receive() re-called this; balances still has funds.
}
// GOOD: checks, then effects, then interactions
function safe() public {
// 1. CHECKS: validate conditions
uint256 amount = balances[msg.sender];
require(amount > 0, "no balance");
// 2. EFFECTS: update state BEFORE external calls
balances[msg.sender] = 0;
// 3. INTERACTIONS: external calls LAST
(bool ok, ) = msg.sender.call{value: amount}("");
require(ok, "send failed");
// If attacker re-enters, balances[msg.sender] is already 0.
}
// Pattern: order your code as
// require() checks first,
// state updates second,
// external calls last.
// This single rule prevents most reentrancy bugs.
// Pair with nonReentrant for defense-in-depth.
}Pull sur Push
Pull sur Push : au lieu de pousser des Ether vers beaucoup de destinataires en une transaction (où un mauvais destinataire bloque tous les autres), créditez le solde de chaque utilisateur et laissez-le tirer ses fonds via withdraw(). Cela isole les échecs (le receive/fallback défaillant d'un utilisateur ne bloque pas les autres) et réduit le gaz par transaction. À utiliser pour airdrops, échanges, paiements d'enchères, remboursements. Combiné à nonReentrant sur withdraw().
contract PullOverPush {
// BAD (push): send Ether to many recipients in one tx
// If any recipient reverts (or is a contract that blocks), the WHOLE tx fails.
mapping(address => uint256) public pendingWithdrawals;
function pushPay(address[] memory recipients) public payable {
uint256 share = msg.value / recipients.length;
for (uint256 i = 0; i < recipients.length; i++) {
// If recipients[i].call fails, the whole loop reverts.
(bool ok, ) = recipients[i].call{value: share}("");
require(ok, "push failed");
}
}
// GOOD (pull): credit each user, let them withdraw individually
function credit(address[] memory recipients) public payable {
uint256 share = msg.value / recipients.length;
for (uint256 i = 0; i < recipients.length; i++) {
pendingWithdrawals[recipients[i]] += share; // just update state
}
}
function withdraw() public {
uint256 amount = pendingWithdrawals[msg.sender];
require(amount > 0, "nothing to withdraw");
pendingWithdrawals[msg.sender] = 0; // effect
(bool ok, ) = msg.sender.call{value: amount}(""); // interaction
require(ok, "withdraw failed");
}
// Pull pattern isolates failures: one user's failed withdrawal
// doesn't block others. Common in: airdrops, exchanges, auctions.
}Pattern Pausable
Le pattern Pausable ajoute un arrêt d'urgence : un booléen 'paused' qui verrouille les fonctions critiques via le modificateur whenNotPaused. Le owner peut pauser/unpauser. À utiliser comme disjoncteur quand un bug ou une attaque est détecté — pausez pour stopper les dégâts pendant la préparation d'un correctif. Souvent combiné aux proxys upgradables (pause, puis déployer la logique patchée). OpenZeppelin fournit un contrat Pausable éprouvé que vous devriez utiliser au lieu de rouler le vôtre.
contract Pausable {
bool public paused;
address public owner;
constructor() { owner = msg.sender; }
modifier whenNotPaused() {
require(!paused, "contract is paused");
_;
}
modifier whenPaused() {
require(paused, "contract is not paused");
_;
}
modifier onlyOwner() {
require(msg.sender == owner, "not owner");
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
}
function unpause() public onlyOwner whenPaused {
paused = false;
}
// Critical functions check whenNotPaused
function deposit() public payable whenNotPaused {
// ...
}
function withdraw(uint256 amount) public whenNotPaused {
// ...
}
// Use case: emergency stop. If a bug is discovered, pause the
// contract to prevent further damage while a fix is prepared.
// Often combined with upgradeable proxies to deploy a patched version.
}
// OpenZeppelin provides Pausable as a reusable contract.Contrôle d'accès
Patterns de contrôle d'accès : (1) Ownable — un seul owner avec le modificateur onlyOwner (simple, centralisé). (2) RBAC — par rôles avec rôles bytes32 et modificateur onlyRole (flexible, multi-admin). (3) Multi-sig ou Timelock — pour les contrats à forte valeur, passez par Gnosis Safe ou OpenZeppelin Timelock. CRUCIAL : utilisez toujours msg.sender pour l'auth, JAMAIS tx.origin (qui peut être usurpé par des contrats intermédiaires malveillants). OpenZeppelin fournit Ownable et AccessControl.
contract AccessControl {
// 1. Simple owner (Ownable pattern)
address public owner;
constructor() { owner = msg.sender; }
modifier onlyOwner() {
require(msg.sender == owner, "not owner");
_;
}
function setOwner(address newOwner) public onlyOwner {
require(newOwner != address(0), "zero address");
owner = newOwner;
}
// 2. Role-based (RBAC)
mapping(bytes32 => mapping(address => bool)) public roles;
bytes32 public constant ADMIN = keccak256("ADMIN");
bytes32 public constant MINTER = keccak256("MINTER");
modifier onlyRole(bytes32 role) {
require(roles[role][msg.sender], "missing role");
_;
}
function grantRole(bytes32 role, address account)
public onlyRole(ADMIN)
{
roles[role][account] = true;
}
function revokeRole(bytes32 role, address account)
public onlyRole(ADMIN)
{
roles[role][account] = false;
}
function mint(address to, uint256 amount) public onlyRole(MINTER) {
// ...
}
// 3. Multi-sig / time-locked (defer to Gnosis Safe or OpenZeppelin Timelock)
// Always use msg.sender (NOT tx.origin) for authorization.
// tx.origin can be spoofed if a user interacts with a malicious
// intermediate contract.
}Standard de token ERC20
Interface ERC20
ERC-20 est le standard des tokens fongibles (USDC, DAI, UNI). L'interface définit 6 fonctions requises (totalSupply, balanceOf, transfer, allowance, approve, transferFrom) et 2 événements (Transfer, Approval). Les métadonnées optionnelles (name, symbol, decimals) sont universellement implémentées. Utilisez toujours le contrat de base ERC20 d'OpenZeppelin pour de nouveaux tokens — audité, gère les cas limites, reconnu par wallets/DEX.
interface IERC20 {
// Events
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
// Metadata (optional but standard)
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
// Required functions
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount)
external returns (bool);
}
// ERC-20 is THE standard for fungible tokens (USDC, DAI, UNI, ...).
// Implemented by thousands of tokens; supported by every wallet/Dex.
// Implementing the interface correctly ensures interoperability.
// Use OpenZeppelin's ERC20 base contract — battle-tested and audited.Fonction Transfer
transfer(to, amount) déplace des tokens de l'appelant vers 'to'. Vérifications standard : adresse destinataire non nulle, solde suffisant. Mettez à jour les soldes AVANT d'émettre l'événement Transfer (pattern CEI). Le mint se modélise comme Transfer depuis address(0) ; le burn comme Transfer vers address(0). Le champ decimals (souvent 18) signifie que les montants sont en unités atomiques (équivalent wei) ; les UI divisent par 10^decimals pour l'affichage.
contract SimpleToken is IERC20 {
string public name = "Simple Token";
string public symbol = "SIM";
uint8 public constant decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
constructor(uint256 _initialSupply) {
totalSupply = _initialSupply;
balanceOf[msg.sender] = _initialSupply;
emit Transfer(address(0), msg.sender, _initialSupply);
}
function transfer(address to, uint256 amount) external returns (bool) {
require(to != address(0), "zero address");
require(balanceOf[msg.sender] >= amount, "insufficient");
balanceOf[msg.sender] -= amount;
balanceOf[to] += amount;
emit Transfer(msg.sender, to, amount);
return true;
}
// Note: 0.8+ auto-checks underflow, so we can simplify:
// balanceOf[msg.sender] -= amount;
// If insufficient, it reverts automatically.
// But explicit require gives clearer error messages.
}Approve et Allowance
approve(spender, amount) fixe combien 'spender' peut transférer en votre nom (via transferFrom). Courant pour les DEX et le staking. ATTENTION : la condition de course d'approve — changer l'allocation de A à B laisse un attaquant dépenser A et B s'il front-run. Mitigez en réglant d'abord à 0, puis à la nouvelle valeur, OU utilisez increaseAllowance/decreaseAllowance (OpenZeppelin). L'événement Approval doit s'émettre à chaque changement.
contract ApprovalExample is IERC20 {
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
// approve: allow 'spender' to spend up to 'amount' on your behalf
function approve(address spender, uint256 amount) external returns (bool) {
require(spender != address(0), "zero address");
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
// Common use cases:
// - DEX trading: approve the DEX router to spend your tokens
// - Staking: approve the staking contract
// - Subscriptions: approve a recurring spender
// WARNING: the approve race condition.
// If you change allowance from 100 to 50, an attacker who saw 100
// could spend 100 BEFORE your tx, then spend 50 AFTER = 150 total.
// Mitigation (EIP-20): set to 0 first, then to new value.
// approve(spender, 0); approve(spender, 50);
// Or use increaseAllowance / decreaseAllowance (OpenZeppelin).
function increaseAllowance(address spender, uint256 added)
public returns (bool)
{
uint256 newAllowance = allowance[msg.sender][spender] + added;
allowance[msg.sender][spender] = newAllowance;
emit Approval(msg.sender, spender, newAllowance);
return true;
}
}TransferFrom
transferFrom(from, to, amount) laisse un spender approuvé déplacer des tokens de 'from' vers 'to'. L'allocation du spender doit être >= amount ; décrémentez l'allocation dans l'étape des effets (CEI). Utilisé par les routeurs DEX, contrats de staking et tout flux de type pull. Caprices des tokens : USDT ne décrémente pas l'allocation ; certains tokens annulent sur des transferts vers l'adresse zéro. Testez toujours avec le token précis avant d'intégrer.
contract TransferFromExample is IERC20 {
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
// transferFrom: spender moves tokens from 'from' to 'to'
// Requires allowance[from][spender] >= amount
function transferFrom(address from, address to, uint256 amount)
external returns (bool)
{
require(to != address(0), "zero address");
require(balanceOf[from] >= amount, "insufficient balance");
require(allowance[from][msg.sender] >= amount, "insufficient allowance");
// Update allowance FIRST (CEI)
allowance[from][msg.sender] -= amount;
balanceOf[from] -= amount;
balanceOf[to] += amount;
emit Transfer(from, to, amount);
return true;
}
// Used by:
// - DEX routers (user approves router, router calls transferFrom)
// - Staking contracts
// - Any 'pull' workflow where a contract takes tokens from a user
// Note on infinite allowance:
// Some tokens (USDT) do NOT decrement allowance on transferFrom,
// and others set allowance to max uint256 by default. Read the
// specific token's docs before integrating.
}Événements ERC20
ERC-20 définit deux événements : Transfer (émis à chaque mouvement de token, y compris mint depuis address(0) et burn vers address(0)) et Approval (émis à chaque changement d'allocation). Ces événements sont la façon dont les dApps et indexeurs (The Graph, Dune, Etherscan) suivent l'activité des tokens sans interroger directement l'état. Émettez-les toujours — les omettre casse l'interopérabilité avec les wallets et échanges qui s'appuient sur les logs.
contract ERC20Events {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
uint256 public totalSupply;
function _mint(address to, uint256 amount) internal {
require(to != address(0), "zero address");
totalSupply += amount;
balanceOf[to] += amount;
// Minting = transfer from address(0)
emit Transfer(address(0), to, amount);
}
function _burn(address from, uint256 amount) internal {
require(balanceOf[from] >= amount, "insufficient");
balanceOf[from] -= amount;
totalSupply -= amount;
// Burning = transfer to address(0)
emit Transfer(from, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
emit Approval(owner, spender, amount);
}
// Events let dApps and indexers (The Graph, Dune) track:
// - Every transfer (incl. mint/burn)
// - Every approval change
// - Token holdings over time
// Without events, integrating with wallets/DEXs is much harder.
}Déploiement et tests
IDE Remix
Remix est la façon la plus simple de démarrer avec Solidity — un IDE navigateur sans installation. Il inclut un compilateur, une VM JavaScript pour les tests locaux, le déploiement vers testnets, un débogueur de transactions et de l'analyse statique. Parfait pour apprendre et prototyper. En production, passez à Hardhat ou Foundry pour le scripting, les tests automatisés et l'intégration CI/CD.
// Remix is a browser-based IDE for Solidity.
// URL: https://remix.ethereum.org
// Features:
// - File explorer, editor, compiler, deployer in one tab
// - Built-in Solidity compiler (no install needed)
// - Deploy to JavaScript VM, local node, or testnet
// - Interact with deployed contracts via GUI
// - Debug transactions step-by-step
// - Static analysis tools (Remix Analyzer)
// Workflow:
// 1. Create a .sol file in the File Explorer
// 2. Compile in the "Solidity Compiler" tab (pick version)
// 3. Deploy in the "Deploy & Run Transactions" tab
// 4. Interact via the deployed contract panel
// Good for: learning, prototyping, quick tests, debugging.
// Not ideal for: production workflows, automated testing, scripting.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract Hello {
string public msg = "Hello from Remix";
}Mise en place Hardhat
Hardhat est un environnement de développement basé JavaScript/TypeScript. Installez via npm, configurez réseaux et compilateur dans hardhat.config.ts. Il fournit compilation, tests (Mocha/Chai), un nœud local (hardhat node), scripts de déploiement et console. Le bundle de plugins Hardhat Toolbox inclut ethers.js, chai, typechain et plus. Utilisez .env pour les secrets (clés privées, URLs RPC).
// Hardhat: JavaScript/TypeScript development environment
// Install: npm install --save-dev hardhat
// Init: npx hardhat init
// hardhat.config.ts
import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
const config: HardhatUserConfig = {
solidity: {
version: "0.8.19",
settings: { optimizer: { enabled: true, runs: 200 } },
},
networks: {
hardhat: {}, // built-in local network
sepolia: {
url: `${process.env.ALCHEMY_URL}`,
accounts: [process.env.PRIVATE_KEY ?? ""],
},
},
};
export default config;
// Project layout:
// contracts/ Solidity source files
// scripts/ deployment scripts (JS/TS)
// test/ test files (Chai/Mocha)
// ignition/ Hardhat Ignition modules (declarative deploy)
// Common commands:
// npx hardhat compile
// npx hardhat test
// npx hardhat run scripts/deploy.ts --network sepolia
// npx hardhat node // start local node
// npx hardhat console // interactive REPLTests Hardhat
Les tests Hardhat utilisent Mocha + Chai + ethers.js. getSigners() retourne des comptes de test avec ETH. connect(addr) envoie une tx depuis un compte précis. Assertions : égalité (equal), reverts (revertedWith), événements (emit + withArgs). TypeChain génère automatiquement des types TypeScript depuis vos ABI, donnant autocomplétion et vérifications à la compilation. Lancez les tests avec 'npx hardhat test'.
// test/Token.test.ts
import { expect } from "chai";
import { ethers } from "hardhat";
import { Token } from "../typechain-types";
describe("Token", () => {
let token: Token;
let owner: any, addr1: any;
beforeEach(async () => {
[owner, addr1] = await ethers.getSigners();
const Factory = await ethers.getContractFactory("Token");
token = await Factory.deploy(1000);
await token.waitForDeployment();
});
it("assigns initial supply to owner", async () => {
expect(await token.balanceOf(owner.address)).to.equal(1000);
});
it("transfers tokens between accounts", async () => {
await token.transfer(addr1.address, 100);
expect(await token.balanceOf(addr1.address)).to.equal(100);
});
it("reverts on insufficient balance", async () => {
await expect(
token.connect(addr1).transfer(owner.address, 1)
).to.be.revertedWith("insufficient");
});
it("emits Transfer event", async () => {
await expect(token.transfer(addr1.address, 100))
.to.emit(token, "Transfer")
.withArgs(owner.address, addr1.address, 100);
});
});
// Run: npx hardhat test
// TypeChain generates typed contract bindings in typechain-types/.Mise en place Foundry
Foundry (forge) est un toolkit Rust rapide où les tests s'écrivent en Solidity même — pas de JavaScript/TypeScript requis. Installez via foundryup. Outils clés : forge (build, test, script), cast (CLI pour appels RPC), anvil (nœud local), chisel (REPL Solidity). Plus rapide que Hardhat et inclut du fuzz testing intégré. Les dépendances sont des git submodules sous lib/. La config vit dans foundry.toml.
// Foundry: Rust-based, fast Solidity dev toolkit
// Install: curl -L https://foundry.paradigm.xyz | bash
// foundryup
// Init: forge init my-project
// Project layout:
// src/ Solidity sources (Default = src/Contract.sol)
// test/ Solidity tests (*.t.sol)
// script/ Deployment scripts (*.s.sol)
// lib/ Dependencies (git submodules, e.g. forge-std, openzeppelin)
// Commands:
// forge build // compile
// forge test // run tests
// forge test -vvv // verbose (shows console logs)
// forge coverage // code coverage
// forge script script/Deploy.s.sol --rpc-url $RPC --broadcast
// Foundry config (foundry.toml):
// [profile.default]
// src = "src"
// out = "out"
// libs = ["lib"]
// solc = "0.8.19"
// optimizer = true
// optimizer_runs = 200
// Why Foundry?
// - Tests are written IN Solidity (no JS/TS context switch)
// - Extremely fast (parallelized, cached)
// - Built-in fuzzing and invariant testing
// - Cast/anvil/chisel CLI tools includedTests Foundry (Solidity)
Les tests Foundry sont des contrats Solidity étendant forge-std/Test. Utilisez assertEq, assertTrue, etc. pour les assertions. Les cheatcodes (vm.*) manipulent l'EVM : vm.prank pour usurper msg.sender, vm.warp pour régler le temps, vm.deal pour frapper des ETH, vm.expectRevert pour affirmer des échecs. Les tests de fuzz (testFuzz_*) génèrent automatiquement des entrées aléatoires sous contraintes (vm.assume). Les tests d'invariants (testInvariant_*) exécutent des séquences aléatoires pour trouver des invariants cassés.
// test/Token.t.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "forge-std/Test.sol";
import "../src/Token.sol";
contract TokenTest is Test {
Token public token;
address owner = address(this);
address user = address(0x1);
function setUp() public {
token = new Token(1000);
}
function testInitialSupply() public view {
assertEq(token.balanceOf(owner), 1000);
}
function testTransfer() public {
token.transfer(user, 100);
assertEq(token.balanceOf(user), 100);
}
function testRevertOnInsufficient() public {
vm.expectRevert("insufficient");
token.transfer(user, 99999);
}
// Fuzz test: 'x' is randomized by the framework
function testFuzzTransfer(uint256 x) public {
vm.assume(x <= 1000);
token.transfer(user, x);
assertEq(token.balanceOf(user), x);
}
// Cheatcodes (vm.*):
// vm.prank(addr) // next call from addr
// vm.startPrank(addr) // all subsequent calls from addr
// vm.warp(timestamp) // set block.timestamp
// vm.roll(blockNum) // set block.number
// vm.deal(addr, 1 ether) // give ETH to addr
// vm.expectRevert(...) // assert next call reverts
// vm.expectEmit(...) // assert next call emits event
}
// Run: forge test -vvvSnippets Solidity associés
Copy-paste ready code for common tasks.
Bases des Contrats
Définir un smart contract basique avec état et fonctions.
Fonctions et Visibilité
Visibilité des fonctions, payable et valeurs de retour.
Modifier et Contrôle d'Accès
Réutiliser la logique de validation avec modifier.
Événements et Logs
Émettre des événements pour les listeners off-chain.
Mapping, Struct et Storage Imbriqué
Grouper des données avec struct, rechercher par clé avec mapping.
Héritage, Abstract et Interface
Réutiliser la logique via héritage ; définir des contrats avec abstract et interface.
Payable, receive et fallback (Flux d'ETH)
Recevoir de l'ETH via fonctions payable et hooks receive/fallback.
Réentrance et Checks-Effects-Interactions
Durcir les contrats contre l'attaque la plus courante aux smart contracts.
Was this helpful?