Les protocoles DeFi · 7 min · démo interactive

Layer 2 et rollups : pourquoi c'est moins cher

Q: Pourquoi un rollup optimistic impose-t-il un délai de retrait ?

Pour laisser le temps de contester un lot frauduleux. Le lot est présumé valide. La fenêtre de contestation permet à n'importe quel vérificateur de prouver une fraude avant que le retrait soit définitif.

Q: Qu'est-ce qui distingue un blob d'EIP-4844 du calldata ?

Il a son propre marché de frais et une durée de conservation limitée. Le gas de blob a un prix de base séparé, et les nœuds de consensus ne gardent les blobs qu'environ 18 jours. La chaîne conserve un engagement.

Q: Pourquoi le coût par transaction baisse-t-il quand le lot grandit ?

Le coût fixe du lot est partagé entre plus de transactions. Le coût fixe se divise par le nombre de transactions. Le coût des données, lui, reste proportionnel : il ne disparaît pas.

Un rollup exécute les transactions à côté d'Ethereum et n'y publie que le résumé. Lance un lot, fais tricher le séquenceur, et regarde qui le rattrape.

L’idée en une phrase

Un layer 2 traite les transactions hors de la chaîne principale, puis publie sur celle-ci assez d'informations pour que personne n'ait à le croire sur parole.

Le coût d'une transaction sur Ethereum vient de la rareté : chaque bloc a une capacité limitée, et chaque nœud doit tout réexécuter. Un rollup déplace l'exécution ailleurs et ne loue que ce dont il a besoin sur la couche 1 : un peu de place pour ses données et une vérification. Ce loyer est partagé entre toutes les transactions du lot.

La démo

Transactions dans le lot Prix du gas de blob, comparé au gas Type de rollup

7 700 odonnées à publier

1 (5,9 %)blobs payés (part utilisée)

1 832gas par tx en calldata

613équivalent gas par tx en blob

Sur L1 directement
Rollup, calldata
Rollup, blob

Lot : 100 transactions, 7 700 octets Hash des données : 00000000000000000000000000000000… Racine annoncée : 00000000000000000000000000000000… Racine recalculée : 00000000000000000000000000000000…

Lot accepté par défaut : personne ne peut prouver de fraude, la fenêtre de contestation expire.

Sans JavaScript, fais le calcul pour 100 transactions d'un rollup optimistic de démonstration. Données : 77 octets par transaction, soit 7 700 octets. En calldata à 16 gas l'octet : 1 232 gas par transaction, plus 600 gas pour la part du coût fixe (60 000 gas divisés par 100). Total : 1 832 gas, contre 21 000 pour un transfert direct. Les tailles et les coûts fixes sont illustratifs, tout comme le rapport de prix du blob. La démo compte en unités, jamais en euros : le prix réel varie sans cesse.

Intégrer cette démo

Copie ce code sur ton site, ton cours ou ton blog. La démo reste gratuite ; garde simplement le lien vers protocole.org.

<iframe src="https://protocole.org/embed/layer-2/" width="100%" height="560" loading="lazy" title="Regrouper 100 transactions en une — protocole.org"></iframe>

Pourquoi ça compte

Imagine cent personnes qui envoient chacune un petit paiement. Sur Ethereum, cela fait cent transactions, chacune avec sa signature vérifiée et ses 21 000 unités de gas. Sur un rollup, un opérateur appelé séquenceur les range dans un lot et publie un seul paquet. Les cent personnes se partagent le prix de ce paquet.

La question n'est donc pas seulement « combien ça coûte ? », mais « que se passe-t-il si l'opérateur triche ? ». Un serveur rapide qui garde tes soldes n'est pas un layer 2. Ce qui fait la différence, c'est qu'un contrat sur Ethereum puisse refuser un faux état, même si le séquenceur est malveillant, et que les données permettent à chacun de reconstituer les soldes.

Le code

Voici le cœur du rollup : exécuter, publier, puis rejouer pour vérifier. Passe tricheur à true, ou change N, et relance.

Code JavaScript modifiable

const N = 100;           // transactions dans le lot
const tricheur = false;  // le séquenceur annonce-t-il un faux état ?

const depart = Array(8).fill(10000);  // soldes des 8 comptes de test

const racine = soldes => P.sha256(JSON.stringify(soldes));
function appliquer(soldes, lot) {
  const s = [...soldes];
  for (const [de, vers, montant] of lot) { s[de] -= montant; s[vers] += montant; }
  return s;
}

// Le séquenceur crée le lot : qui paie qui, combien
const lot = [];
const courant = [...depart];
for (let i = 0; i < N; i++) {
  const de = Math.floor(Math.random() * 8);
  const vers = (de + 1 + Math.floor(Math.random() * 7)) % 8;
  const montant = Math.min(courant[de], 1 + Math.floor(Math.random() * 100));
  courant[de] -= montant; courant[vers] += montant;
  lot.push([de, vers, montant]);
}

// Il publie les données et annonce la nouvelle racine d'état
const etatAnnonce = [...courant];
if (tricheur) etatAnnonce[7] += 50000;
const annonce = racine(etatAnnonce);

// N'importe qui rejoue les données publiées depuis l'ancien état
const recalcul = racine(appliquer(depart, lot));

console.log('Racine annoncée  :', annonce.slice(0, 24));
console.log('Racine recalculée:', recalcul.slice(0, 24));
console.log(annonce === recalcul ? 'Lot cohérent' : 'FRAUDE : contestation possible');

// Le partage du coût, en gas
const gasL1 = N * 21000;
const parOctet = 16, octets = N * 77, fixe = 60000;  // illustratif
const gasLot = fixe + octets * parOctet;
console.log('En direct sur L1 :', gasL1, 'gas');
console.log('Lot en calldata  :', gasLot, 'gas, soit', Math.round(gasLot / N), 'par transaction');
console.log('Blobs entiers à payer :', Math.ceil(octets / 131072));

Clique sur Lancer pour exécuter ce code dans ton navigateur.

Ce qui se passe vraiment

Le graphique : un coût fixe partagé

La ligne droite représente un transfert simple sur la couche 1 : 21 000 gas, quel que soit le nombre d'utilisateurs. Les courbes du rollup descendent, car chaque lot a un coût fixe, divisé par le nombre de participants. Augmente le curseur : la courbe s'aplatit, et il reste le coût des données, qui ne se partage pas.

C'est pourquoi tout rollup cherche à publier le moins d'octets possible. Il remplace les adresses de 20 octets par des index, retire les champs déductibles et compresse le lot. Passe d'optimistic à ZK : les données tombent de 77 à 12 octets par transaction dans la démo, mais le coût fixe grimpe, car vérifier une preuve coûte plus cher. Les petits lots ZK reviennent donc plus cher, puis l'avantage s'inverse quand le lot grossit.

Deux réponses à la triche

Un rollup optimistic présume le lot honnête et laisse une fenêtre de contestation, le plus souvent de sept jours. Pendant ce délai, n'importe qui peut rejouer les données et prouver une fraude sur la chaîne. Il suffit d'un seul vérificateur honnête. Le rollup doit publier les signatures, car chacun doit pouvoir tout rejouer : ce sont les 65 octets de plus de la démo. Clique sur « Faire tricher le séquenceur » : la racine annoncée diffère de celle que le vérificateur recalcule.

Un rollup ZK joint une preuve de validité : un petit objet mathématique qui atteste que l'exécution est correcte, vérifié par un contrat. Aucun délai de contestation n'est nécessaire, et un faux état ne peut pas recevoir de preuve valide. La preuve garantit les signatures, qui n'ont plus à être publiées. Le prix à payer : la génération des preuves demande beaucoup de calcul et des circuits complexes.

Les blobs d'EIP-4844

Jusqu'en mars 2024, les rollups écrivaient leurs données dans le calldata, une zone prévue pour les entrées des contrats, qui alourdit durablement l'historique de la chaîne. La mise à jour Dencun a introduit les blobs (EIP-4844), un espace pensé pour eux. Trois différences comptent.

Un marché de frais séparé. Le gas de blob a son propre prix de base, qui monte ou descend selon la demande de blobs, indépendamment du gas ordinaire. C'est pourquoi la démo demande un rapport de prix : il n'est pas fixe et ne mesure rien de réel.
Une durée de vie limitée. Les nœuds de consensus conservent un blob environ 18 jours, puis peuvent le supprimer. La chaîne ne garde qu'un engagement cryptographique (KZG). Cette durée suffit pour contester un lot et laisser chacun se synchroniser, sans alourdir l'historique pour toujours.
Illisible par la machine virtuelle. Un contrat ne voit que le hash de l'engagement, pas le contenu. Il peut seulement vérifier qu'un point appartient bien au blob.

Un blob fait 128 Kio (131 072 octets) et se paie entier. Regarde la statistique « part utilisée » : un lot de 100 transactions n'occupe qu'une fraction du blob, et paie tout de même sa totalité. Les séquenceurs ont donc intérêt à attendre que leurs blobs soient bien remplis.

La démo simplifie beaucoup. L'état est un simple hash des soldes, et non un arbre de Merkle. La preuve ZK est simulée par un recalcul, le coût d'exécution sur le L2 est ignoré, et le plancher de prix du calldata introduit depuis par EIP-7623 n'est pas pris en compte.

Dans la vraie vie

Arbitrum et OP Mainnet sont des exemples techniques de rollups optimistic ; zkSync Era, Starknet, Linea et Scroll de rollups ZK. Dans tous les cas, ton expérience diffère peu, mais le moment du retrait change. Sur un optimistic, le pont officiel impose d'attendre la fin de la fenêtre. Sur un ZK, il faut attendre que la preuve soit publiée et vérifiée. Des services tiers offrent un retrait plus rapide en avançant les fonds, avec leur propre risque de bridge.

La confirmation quasi instantanée que tu vois sur un L2 est une promesse du séquenceur. La finalité complète n'arrive qu'une fois les données publiées et le bloc Ethereum correspondant finalisé.

Les rollups diffèrent aussi de Lightning : celui-ci règle l'essentiel entre participants d'un canal, sans publier chaque paiement, alors qu'un rollup publie tout, sous forme comprimée, sur la couche 1.

Ce qui peut mal tourner

Le séquenceur unique. Beaucoup de rollups s'appuient sur un seul opérateur. Il peut retarder ou réordonner des transactions, ou tomber en panne. Une bonne conception prévoit une sortie forcée via la couche 1, à vérifier projet par projet.
Les clés de mise à jour. Si une équipe peut modifier le contrat du rollup sans délai, elle peut en théorie changer les règles, quelles que soient les preuves. La maturité d'un L2 se juge aussi à cela.
Un système de preuve absent ou limité. Une preuve de fraude qui n'est pas déployée, ou réservée à une liste d'acteurs, ne protège pas comme annoncé. Un circuit ZK peut aussi contenir un bug.
Les données hors d'Ethereum. Un système qui publie ses données ailleurs (validium) est moins cher, mais si ces données deviennent indisponibles, personne ne peut reconstituer les soldes.
Le retrait précipité. Croire que les fonds sortent immédiatement d'un optimistic est une erreur courante : le délai fait partie de la sécurité.
Les faux ponts. Les interfaces imitant un pont officiel sont une forme classique de phishing. Vérifie l'adresse depuis la documentation du projet.

Teste-toi

1. Pourquoi un rollup optimistic impose-t-il un délai de retrait ? Pour laisser le temps de contester un lot frauduleux Pour que les frais baissent Parce qu'Ethereum produit peu de blocs

2. Qu'est-ce qui distingue un blob d'EIP-4844 du calldata ? Il est conservé pour toujours par tous les nœuds Le contrat peut lire tout son contenu Il a son propre marché de frais et une durée de conservation limitée

3. Pourquoi le coût par transaction baisse-t-il quand le lot grandit ? Le séquenceur fait une remise Le coût fixe du lot est partagé entre plus de transactions Les octets deviennent gratuits

Contenu éducatif. Pas un conseil en investissement. Les crypto-actifs comportent un risque de perte en capital. Pour la démarche éditoriale, voir à propos. Mise à jour : 31 octobre 2026.