: enc(X)` est l'encodage gros-boutiste en complément à deux de X, ajouté sur le côté supérieur (gauche) avec 0xff pour X négatif et avec zéro > octets pour X positif de sorte que la longueur est un multiple de 32 octets.
+
+Ceci encode en `0000000000000000000000000000000000000000000000000000000000000006`.
+
+La combinaison du sélecteur de fonction et de l'argument encodé sera `0xc6888fa10000000000000000000000000000000000000000000000000000000000000006`.
+
+Cela peut maintenant être envoyé au nœud :
+
+```bash
+curl --data '{"jsonrpc":"2.0","method": "eth_sendTransaction", "params": [{"from": "0xeb85a5557e5bdc18ee1934a89d8bb402398ee26a", "to": "0x6ff93b4b46b41c0c3c9baee01c255d3b4675963d", "data": "0xc6888fa10000000000000000000000000000000000000000000000000000000000000006"}], "id": 8}' -H "Content-Type: application/json" localhost:8545
+{"id":8,"jsonrpc":"2.0","result":"0x759cf065cbc22e9d779748dc53763854e5376eea07409e590c990eafc0869d74"}
+```
+
+Puisqu'une transaction a été envoyée, un hachage de transaction a été retourné. La récupération du reçu :
+
+```javascript
+{
+ blockHash: "0xbf0a347307b8c63dd8c1d3d7cbdc0b463e6e7c9bf0a35be40393588242f01d55",
+ blockNumber: 268,
+ contractAddress: null,
+ cumulativeGasUsed: 22631,
+ gasUsed: 22631,
+ logs: [{
+ address: "0x6ff93b4b46b41c0c3c9baee01c255d3b4675963d",
+ blockHash: "0xbf0a347307b8c63dd8c1d3d7cbdc0b463e6e7c9bf0a35be40393588242f01d55",
+ blockNumber: 268,
+ data: "0x000000000000000000000000000000000000000000000000000000000000002a",
+ logIndex: 0,
+ topics: ["0x24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da"],
+ transactionHash: "0x759cf065cbc22e9d779748dc53763854e5376eea07409e590c990eafc0869d74",
+ transactionIndex: 0
+ }],
+ transactionHash: "0x759cf065cbc22e9d779748dc53763854e5376eea07409e590c990eafc0869d74",
+ transactionIndex: 0
+}
+```
+
+Le reçu contient un journal d'activités. Ce journal a été généré par l'EVM lors de l'exécution de la transaction et est inclus dans le reçu. La fonction `multiply` montre que l'événement `Print` a été levé avec le temps d'entrée 7. Puisque l'argument de l'événement `Print` était un uint256, nous pouvons le décoder selon les règles ABI qui nous laisseront avec la décimale prévue 42. Mis à part les données, il est intéressant de noter que les sujets peuvent être utilisés pour déterminer quel événement a créé le journal :
+
+```javascript
+web3.sha3("Print(uint256)")
+// "24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da"
+```
+
+Il ne s'agissait que d'une brève introduction à certaines des tâches les plus courantes, démontrant l'utilisation directe du JSON-RPC.
+
## Sujets connexes {#related-topics}
-- [Nœuds et clients](/developers/docs/nodes-and-clients/)
+- [Spécification JSON-RPC](http://www.jsonrpc.org/specification)
+- [ Nœuds et clients](/developers/docs/nodes-and-clients/)
- [API JavaScript](/developers/docs/apis/javascript/)
-- [API backend](/developers/docs/apis/backend/)
+- [API back-end](/developers/docs/apis/backend/)
+- [Clients d'exécution](/developers/docs/nodes-and-clients/#execution-clients)
diff --git a/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/index.md b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/index.md
index 5b825dbec3d..e4f53f65b7c 100644
--- a/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/index.md
+++ b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/index.md
@@ -2,12 +2,13 @@
title: Preuve de travail (PoW)
description: Explication du protocole de consensus « preuve de travail » et de son rôle dans Ethereum.
lang: fr
-incomplete: true
---
-Ethereum, comme Bitcoin, utilise actuellement un protocole de consensus appelé **[preuve de travail (PoW)](https://wikipedia.org/wiki/Proof_of_work)**. Celui-ci permet à l'ensemble du réseau Ethereum de s'accorder sur l'état de toutes les informations enregistrées sur la blockchain Ethereum, empêchant ainsi certains types d'attaques économiques.
+Le réseau Ethereum a commencé par utiliser un mécanisme de consensus basé sur la **[Preuve de travail (PoW)](/developers/docs/consensus-mechanisms/pow)**. Cela permet à l'ensemble des nœuds du réseau Ethereum de s'accorder sur l'état de toutes les informations enregistrées sur la blockchain Ethereum, empêchant ainsi certains types d'attaques économiques. Ethereum a néanmoins abandonné la preuve de travail en 2022 et a commencé à utiliser la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos).
-Au cours de la prochaine année, la preuve de travail sera progressivement abandonnée au profit de la **[preuve d'enjeu (PoS)](/developers/docs/consensus-mechanisms/pos)**. La transition vers la preuve d'enjeu supprimera également progressivement le minage depuis Ethereum. [En savoir plus sur la fusion.](/roadmap/merge/)
+
+ La preuve de travail est maintenant obsolète. Ethereum n'utilise plus la preuve de travail dans le cadre de son mécanisme de consensus. En lieu et place, Ethereum utilise la preuve d'enjeu. En savoir plus sur la preuve d'enjeu et le staking.
+
## Prérequis {#prerequisites}
@@ -15,63 +16,59 @@ Pour mieux comprendre cette page, nous vous recommandons de commencer par lire c
## Qu'est ce que la preuve de travail (PoW) ? {#what-is-pow}
-La preuve de travail est le mécanisme qui permet au réseau décentralisé Ethereum de parvenir à un consensus, ou de s'accorder sur les soldes des comptes ainsi que l'ordre des transactions. Cela empêche les utilisateurs d'effectuer une « double dépense » et garantit qu'il est extrêmement difficile d'attaquer la chaîne Ethereum ou de la manipuler.
+Le consensus Nakamoto, qui utilise la preuve de travail, est le mécanisme qui a autrefois permis au réseau Ethereum décentralisé de parvenir à un consensus (c.-à-d. que l'ensemble des nœuds sont d'accord) sur des choses telles que les soldes des comptes et l'ordre des transactions. Cela empêche les utilisateurs d'effectuer une « double dépense » et garantit qu'il est extrêmement difficile d'attaquer la chaîne Ethereum ou de la manipuler. Ces propriétés de sécurité proviennent désormais de la preuve d'enjeu, en utilisant le mécanisme de consensus connu sous le nom de [Gasper](/developers/docs/consensus-mechanisms/pos/gasper/).
## Preuve de travail et minage {#pow-and-mining}
-La preuve de travail est l'algorithme sous-jacent qui définit la difficulté et les règles pour le travail des mineurs. Le minage est le « travail » en lui-même. C'est l'acte d'ajouter des blocs valides à la chaîne. C'est important car la longueur de chaîne aide le réseau à repérer la chaîne Ethereum valide et à comprendre l'état actuel d'Ethereum. Plus il y a de « travail » effectué, plus la chaîne est longue, plus le nombre de blocs est élevé, plus le réseau peut être certain de l'état actuel des choses.
+La preuve de travail est l'algorithme sous-jacent qui définit la difficulté et les règles pour le travail réalisé par les mineurs sur les blockchains de preuve de travail. Le minage est le « travail » en lui-même. C'est l'acte d'ajouter des blocs valides à la chaîne. Ce point est important, dans la mesure où la longueur de la chaîne aide le réseau à suivre la bonne fourche de la blockchain. Plus il y a de « travail » effectué, plus la chaîne est longue, plus le nombre de blocs est élevé, plus le réseau peut être certain de l'état actuel des choses.
[En savoir plus sur le minage](/developers/docs/consensus-mechanisms/pow/mining/)
-## Comment fonctionne la preuve de travail Ethereum ? {#how-it-works}
+## Comment fonctionne la preuve de travail pour Ethereum ? {#how-it-works}
-Les transactions Ethereum sont traitées en blocs. Chaque bloc possède :
+Les transactions Ethereum sont traitées en blocs. Avec le processus désormais obsolète de preuve de travail d'Ethereum, chaque bloc contenait :
- une difficulté de bloc (par ex. : 3,324,092,183,262,715) ;
- un mixHash (par ex. : `0x44bca881b07a6a09f83b130798072441705d9a665c5ac8bdf2f39a3cdf3bee29`) ;
- un nonce (par ex. : `0xd3ee432b4fb3d26b`).
-Ces données de bloc sont directement liées à la preuve de travail.
+Ces données de bloc étaient directement liées à la preuve de travail.
### Le travail en preuve de travail {#the-work}
Le protocole de preuve de travail, Ethash, exige des mineurs qu'ils se livrent à une intense course d'essais et d'erreurs pour trouver le nonce d'un bloc. Seuls les blocs avec un nonce valide peuvent être ajoutés à la chaîne.
-Lors de la course pour créer un bloc, un mineur soumet de façon répétée un ensemble de données (qu'il ne peut obtenir qu'en téléchargeant et en exécutant la chaîne complète) à une fonction mathématique. Le jeu de données est utilisé pour générer un mixHash en dessous d'un nonce cible, dicté par la difficulté du bloc. La meilleure façon d'y arriver est de faire des essais et des erreurs.
+Lors de la course visant à créer un bloc, un mineur soumet de façon répétée un ensemble de données (qu'il ne peut obtenir qu'en téléchargeant et en exécutant la chaîne complète, comme le fait un mineur) à une fonction mathématique. Le jeu de données est utilisé pour générer un mixHash en dessous d'une cible dictée par la difficulté du bloc. La meilleure façon d'y arriver est de faire des essais et des erreurs.
La difficulté détermine la cible du hachage. Plus la cible est basse, plus l'ensemble de hachages valides est petit. Une fois généré, il est incroyablement facile à vérifier pour les autres mineurs et clients. Même si une transaction devait changer, le hachage serait complètement différent, signalant une fraude.
-Le hachage facilite le dépistage de la fraude. Mais la preuve de travail en tant que processus est aussi un excellent moyen de dissuader ceux qui veulent attaquer la chaîne.
+Le hachage facilite la détection de la fraude. Mais la preuve de travail en tant que processus était aussi un excellent moyen de dissuasion contre les attaques de la chaîne.
### Preuve de travail et sécurité {#security}
-Les mineurs sont encouragés à faire ce travail sur la chaîne principale Ethereum. Il n’y a guère d’intérêt pour un sous-ensemble de mineurs à démarrer leur propre chaîne. Cela sape le système. Les blockchains reposent sur un seul état comme source de vérité. Et les utilisateurs choisiront toujours la chaîne la plus longue ou la plus « lourde ».
+Les mineurs étaient encouragés à faire ce travail sur la chaîne principale Ethereum. Il n’y avait guère d’intérêt pour un sous-ensemble de mineurs à démarrer leur propre chaîne. Cela saperait le système. Les blockchains reposent sur un seul état comme source de vérité.
-L'objectif de la preuve de travail est d'étendre la chaîne. La chaîne la plus longue est la plus crédible en terme de validité, car c'est elle qui dispose de plus de travail de calcul. Dans le système de preuve de travail Ethereum, il est presque impossible de créer de nouveaux blocs qui effacent les transactions, en créent de fausses, ou de maintenir une seconde chaîne. C'est parce qu'un mineur malveillant devrait toujours résoudre le bloc plus rapidement que tout le monde.
+L'objectif de la preuve de travail était d'étendre la chaîne. La chaîne la plus longue était la plus crédible en termes de validité, car elle enregistrait le travail de calcul le plus important pour la générer. Dans le système de preuve de travail Ethereum, il était presque impossible de créer de nouveaux blocs susceptibles d'effacer les transactions, d'en créer de fausses, ou de maintenir une seconde chaîne. C'est parce qu'un mineur malveillant aurait toujours dû résoudre le nonce du bloc plus rapidement que les autres.
-Pour créer systématiquement des blocs malveillants mais valides, vous auriez besoin de plus de 51 % de la puissance de minage du réseau pour battre tout le monde. Une énorme puissance de calcul serait nécessaire pour pouvoir effectuer cette quantité de « travail ». Et l'énergie dépensée pourrait même l'emporter sur les gains que vous feriez lors d'une attaque.
+Pour créer de manière constante des blocs malveillants mais valides, un mineur malhonnête aurait besoin de plus de 51 % de la puissance de minage du réseau pour battre tout le monde. Cette quantité de « travail » nécessite une énorme et coûteuse puissance informatique et l'énergie dépensée pourrait même dépasser les gains obtenus avec une attaque.
### Économie de la preuve de travail {#economics}
-La preuve de travail est également responsable de l'émission de nouvelles devises dans le système et encourage les mineurs à faire le travail.
+La preuve de travail était également responsable de l'émission de nouvelles devises dans le système et encourageait les mineurs à y travailler.
-Les mineurs qui ont réussi à créer un bloc sont récompensés par deux ETH fraîchement frappés mais ne reçoivent plus tous les frais de transaction puisque les frais de base sont brûlés, tandis que le pourboire et la récompense du bloc vont au mineur. Un mineur peut également obtenir 1,75 ETH pour un bloc « oncle ». Les blocs « oncle » sont des blocs valides créés par un mineur pratiquement en même temps qu'un autre mineur a miné le bloc avec succès. Les blocs « oncle » apparaissent généralement en raison de la latence du réseau.
+Depuis [la mise à jour Constantinople](/history/#constantinople), les mineurs ayant réussi à créer un bloc étaient récompensés par deux ETH fraîchement minés et une partie des frais de transaction. Les blocs Ommer étaient également récompensés par 1,75 ETH. Les blocs Ommer étaient des blocs valides créés par un mineur pratiquement en même temps qu'un autre mineur créait le bloc canonique, qui était finalement déterminé par la chaîne construite en premier. Les blocs Ommer apparaissaient généralement en raison de la latence du réseau.
## Finalisation {#finality}
-Une transaction est « finalisée » sur Ethereum lorsqu'elle fait partie d'un bloc qui ne peut pas changer.
+Une transaction était « finalisée » sur Ethereum lorsqu'elle faisait partie d'un bloc qui ne pouvait pas changer.
-Parce que les mineurs travaillent de manière décentralisée, deux blocs valides peuvent être minés en même temps. Cela crée une fourche temporaire. Finalement, l'une de ces chaînes deviendra la chaîne acceptée après qu'un bloc suivant aura été miné et ajouté, ce qui la rendra plus longue.
+Dans la mesure où les mineurs travaillaient de manière décentralisée, deux blocs valides pouvaient être minés en même temps. Cela créait une fourche temporaire. Finalement, l'une de ces chaînes devenait la chaîne acceptée après qu'un bloc suivant aura été miné et ajouté, ce qui la rendra plus longue.
-Mais pour compliquer davantage les choses, les transactions rejetées sur la fourche temporaire auront peut-être été incluses dans la chaîne acceptée. Cela signifie que cela pourrait être inversé. La finalisation fait dont référence au délai que vous devez attendre avant de considérer une transaction comme irréversible. Pour Ethereum, le délai recommandé est de six blocs ou un peu plus d'une minute. Après six blocs, vous pouvez penser avec une relative confiance que la transaction est réussie. Vous pouvez attendre plus longtemps pour que votre assurance soit encore plus grandes.
-
-La finalisation est une chose à garder à l'esprit lors de la conception de dApps. Ce serait une mauvaise expérience utilisateur de dénaturer les informations de transaction à vos utilisateurs, surtout si la transaction est de grande valeur.
-
-N'oubliez pas que ce délai n'inclut pas les temps d'attente pour qu'une transaction soit prise en charge par un mineur.
+Mais pour compliquer davantage les choses, les transactions rejetées sur la fourche temporaire pouvaient ne pas avoir été incluses dans la chaîne acceptée. Cela signifie qu'elle pourrait être inversée. La finalisation fait dont référence au temps que vous devez attendre avant de considérer une transaction comme irréversible. Dans le cadre de la précédente preuve de travail d'Ethereum, plus le nombre de blocs minés au-dessus d'un bloc spécifique `N` était élevé, plus la confiance dans les transactions de `N` était élevée et n'était pas inversée. Désormais, avec la preuve d'enjeu, la finalisation d'un bloc est une propriété explicite, plutôt que probabiliste.
## Consommation d'énergie et preuve de travail {#energy}
-Une critique majeure de la preuve de travail est la quantité d'énergie nécessaire pour assurer la sécurité du réseau. Pour maintenir la sécurité et la décentralisation, Ethereum en preuve de travail consomme chaque année 73,2 TWh, l'équivalent énergétique d'un pays de taille moyenne comme l'Autriche.
+Une critique majeure de la preuve de travail est la quantité d'énergie nécessaire pour assurer la sécurité du réseau. Pour maintenir la sécurité et la décentralisation, Ethereum consommait de grandes quantités d'énergie avec la preuve de travail. Peu avant de passer à la preuve d'enjeu, les mineurs d'Ethereum consommaient collectivement environ 70 TWh/an (à peu près autant que la République tchèque - selon le [digiconomist](digiconomist.net) le 18 juillet-2022).
## Avantages et inconvénients {#pros-and-cons}
@@ -99,7 +96,7 @@ Une critique majeure de la preuve de travail est la quantité d'énergie nécess
## Complément d'information {#further-reading}
- [Attaque de la majorité](https://en.bitcoin.it/wiki/Majority_attack)
-- [Finalisation du règlement](https://blog.ethereum.org/2016/05/09/on-settlement-finality/)
+- [A propos de l'accord de finalisation](https://blog.ethereum.org/2016/05/09/on-settlement-finality/)
### Vidéos {#videos}
diff --git a/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/index.md b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/index.md
index 1316a3cdcef..832c5f41e31 100644
--- a/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/index.md
+++ b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/index.md
@@ -1,44 +1,47 @@
---
title: Minage
-description: Une explication du fonctionnement du minage sur Ethereum et de la façon dont il aide à garder Ethereum sécurisé et décentralisé.
+description: Une explication de la façon dont le minage fonctionnait sur Ethereum.
lang: fr
-incomplete: true
---
+
+La preuve de travail n'est plus le mécanisme de consensus d'Ethereum, ce qui implique que le minage a été désactivé. À la place, Ethereum est sécurisé par les validateurs qui misent de l'ETH. Vous pouvez commencer à miser votre ETH aujourd'hui. En savoir plus sur La Fusion, la preuve d'enjeu et la mise en jeu. Cette page n'a qu'un intérêt historique.
+
+
## Prérequis {#prerequisites}
Pour mieux comprendre cette page, nous vous recommandons de commencer par lire celles concernant [les transactions](/developers/docs/transactions/), [les blocs](/developers/docs/blocks/) et [la preuve de travail](/developers/docs/consensus-mechanisms/pow/).
## Qu'est-ce que le minage Ethereum ? {#what-is-ethereum-mining}
-Le minage est le processus de création d'un bloc de transactions à ajouter à la blockchain Ethereum.
+Le minage est le processus de création d'un bloc de transactions à ajouter à la blockchain Ethereum dans l'architecture de preuve de travail, désormais obsolète, pour Ethereum.
-Ethereum, comme Bitcoin, utilise actuellement un mécanisme de consensus appelé [preuve de travail (PoW)](/developers/docs/consensus-mechanisms/pow/). Le minage est l’essence même de la preuve de travail. Les mineurs d'Ethereum (les ordinateurs qui exécutent des logiciels) utilisent leur temps et leur puissance de calcul pour traiter les transactions et produire des blocs.
+Le terme « minage » trouve son origine dans la comparaison avec l'or des crypto-monnaies. L'or et les métaux précieux sont rares, tout comme les jetons numériques, et le seul moyen d'en augmenter le volume dans le cadre du système de preuve de travail est le minage. Dans le cadre de la preuve de travail Ethereum, le seul mode d’émission était le minage. À la différence du minage historique de l'or ou des métaux précieux, le minage avec Ethereum permet également de sécuriser le réseau en créant, vérifiant, publiant et propageant de nouveaux blocs dans la blockchain.
-
- La Preuve d'enjeu remplacera le minage et la Preuve de travail au cours de l'année prochaine. Vous pouvez commencer à miser votre ETH aujourd'hui. En savoir plus sur les mises
-
+Miner de l'ether = Sécuriser le réseau
+
+Le minage est la colonne vertébrale de toute blockchain utilisant la preuve de travail. Les mineurs d'Ethereum - les ordinateurs qui exécutent des logiciels - utilisaient leur puissance de temps et de calcul pour traiter les transactions et produire des blocs avant la transition vers la preuve d'enjeu.
## Pourquoi existe-t-il des mineurs ? {#why-do-miners-exist}
-Dans les systèmes décentralisés comme Ethereum, nous devons nous assurer que tout le monde s'accorde sur l'ordre des transactions. Les mineurs aident à cela en résolvant des casse-têtes complexes sur le plan informatique afin de produire des blocs, qui constituent un moyen de sécuriser le réseau des attaques.
+Dans les systèmes décentralisés comme Ethereum, nous devons nous assurer que tout le monde s'accorde sur l'ordre des transactions. Les mineurs y contribuent en résolvant des casse-têtes informatiques complexes pour produire des blocs, sécurisant également ainsi le réseau contre les attaques.
[En savoir plus sur la preuve de travail](/developers/docs/consensus-mechanisms/pow/)
-## Qui peut devenir mineur sur Ethereum ? {#who-can-become-a-miner}
-
-Techniquement, n'importe qui peut exploiter le réseau Ethereum à l'aide de son ordinateur. Cependant, tout le monde ne peut pas exploiter l'éther (ETH) de manière rentable. Dans la plupart des cas, les mineurs doivent acheter du matériel informatique dédié pour exploiter de manière rentable. S'il est vrai que n'importe qui peut exécuter le logiciel de minage sur son ordinateur, il est peu probable que l'ordinateur moyen gagne suffisamment de récompenses globales pour couvrir les coûts associés au minage.
+Auparavant, n'importe qui pouvait miner sur le réseau Ethereum à l'aide de son ordinateur. Cependant, tout le monde ne pouvait pas miner de l'éther (ETH) de manière rentable. Dans la plupart des cas, les mineurs devaient acheter du matériel informatique et des logiciels dédiés et avoir accès à des sources d'énergie peu coûteuses. Il était peu probable que l'ordinateur moyen gagne suffisamment de récompenses de blocs pour couvrir les coûts associés au minage.
### Coût du minage {#cost-of-mining}
- Coûts potentiels du matériel nécessaire pour construire et entretenir une plate-forme minière
- Coût électrique de l'alimentation de la plate-forme minière
-- Si vous minez dans un pool, les pools de minage facturent généralement des frais fixes en % de chaque bloc généré par le pool
+- Si vous miniez au sein d'un pool, ces derniers facturaient généralement des frais fixes en % de chaque bloc généré par le pool
- Coût potentiel de l'équipement pour soutenir la plate-forme minière (ventilation, surveillance de l'énergie, câblage électrique, etc.)
Pour explorer davantage la rentabilité du minage, utilisez un calculateur de minage, tel que celui fourni par [Etherscan](https://etherscan.io/ether-mining-calculator).
-## Comment les transactions Ethereum sont-elles minées ? {#how-ethereum-transactions-are-mined}
+## Comment les transactions Ethereum étaient-elles minées ? {#how-ethereum-transactions-were-mined}
+
+Ce qui suit donne un aperçu de la façon dont les transactions ont été exécutés dans la preuve de travail Ethereum. Une description analogue de ce processus pour la preuve d'enjeu Ethereum peut être trouvée [ici](/developers/docs/consensus-mechanisms/pos/#transaction-execution-ethereum-pos).
1. Un utilisateur rédige et signe une demande de [transaction](/developers/docs/transactions/) avec la clé privée d'un [compte](/developers/docs/accounts/).
2. L'utilisateur diffuse la demande de transaction sur l'ensemble du réseau Ethereum à partir de certains [nœuds](/developers/docs/nodes-and-clients/).
@@ -51,21 +54,25 @@ Pour explorer davantage la rentabilité du minage, utilisez un calculateur de mi
7. Chaque nœud supprime toutes les transactions du nouveau bloc de son mempool local de demandes de transaction non satisfaites.
8. Les nouveaux nœuds qui rejoignent le réseau téléchargent tous les blocs en séquence, y compris le bloc contenant la transaction qui nous intéresse. Ils initialisent une copie locale de l'EVM (qui débute en tant qu'EVM vide), puis commencent l'exécution de chaque transaction dans chaque bloc en plus de leur copie locale de l'EVM, en vérifiant la somme de contrôle de l'état de chaque bloc dans le processus.
-Chaque transaction est minée (incluse dans un nouveau bloc et propagée pour la première fois) une fois, mais exécutée et vérifiée par chaque participant du processus d'avancement vers l'état conforme de l'EVM. Ceci met en avant l'une des devises de la blockchain : **Ne faites pas confiance, vérifiez**.
+Chaque transaction est minée (incluse dans un nouveau bloc et propagée pour la première fois) une fois, mais exécutée et vérifiée par chaque participant au processus d'avancement vers l'état conforme de l'EVM. Cette approche met en avant l'une des principales devises de la blockchain : **Ne faites pas confiance, vérifiez**.
+
+## Blocs ommer (oncle) {#ommer-blocks}
+
+Le minage du bloc reposant sur la preuve de travail (PoW) n'était alors que probabiliste, ce qui signifie que, parfois, il arrivait que deux blocs, ayant déjà été validés, soient en même temps exposés au public, notamment en raison de la latence du réseau. Dans ce cas, le protocole devait déterminer la chaîne la plus longue (et donc la plus « valide ») tout en assurant l'équité envers les mineurs en récompensant partiellement le bloc valide non inclus proposé. Cela a encouragé une plus grande décentralisation du réseau pour les mineurs plus petits, qui pourraient être confrontés à une plus grande latence, leur permettant de générer des rendements par le biais d'un bloc de récompenses [ommer](/glossary/#ommer) .
+
+On utilise de préférence le terme « ommer », plus neutre, pour désigner le frère ou la sœur d'un bloc parent, mais on parle aussi parfois d'« oncle ». **Depuis le passage d'Ethereum à la preuve d'enjeu, les blocs Ommer ne sont plus minés** puisque seulement un acteur de l'écosystème peut être élu dans chaque slot. Vous pouvez voir ce changement en visualisant le [graphique historique](https://ycharts.com/indicators/ethereum_uncle_rate) des blocs Ommer minés.
## Démonstration visuelle {#a-visual-demo}
-Regardez Austin vous guider à travers le minage et la blockchain.
+Regardez Austin vous guider à travers le minage et la blockchain de la preuve de travail.
-## Complément d'information {#further-reading}
+## L'algorithme de minage {#mining-algorithm}
-## Outils connexes {#related-tools}
+Le réseau principal Ethereum n'a jamais utilisé qu'un seul algorithme de minage - ['Ethash'](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash). Ethhash était le successeur d'un algorithme R&D original connu sous le nom de ["Dagger-Hashimoto"](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto).
-- [Meilleurs mineurs d'Ethereum](https://etherscan.io/stat/miner?range=7&blocktype=blocks)
-- [Calculateur de minage Etherscan](https://etherscan.io/ether-mining-calculator)
-- [Calculateur de minage Minerstat](https://minerstat.com/coin/ETH)
+[Plus de détails sur les algorithmes de minage](/developers/docs/consensus-mechanisms/pow/mining-algorithms/).
## Sujets connexes {#related-topics}
diff --git a/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md
new file mode 100644
index 00000000000..73b6e39b976
--- /dev/null
+++ b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md
@@ -0,0 +1,334 @@
+---
+title: Dagger-Hashimoto
+description: Un regard détaillé sur l'algorithme Dagger-Hashimoto.
+lang: fr
+---
+
+Dagger-Hashimoto représentait l'implémentation et la spécification originales de recherche pour l'algorithme de minage d'Ethereum. Dagger-Hashimoto a été remplacé par [Ethash](#ethash). Le minage a été complètement arrêté avec [La Fusion](/updates/merge) du 15 septembre 2022. Depuis lors, Ethereum a été sécurisé en utilisant à la place un mécanisme de [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos). Cette page a un intérêt historique - l'information fournie n'est plus pertinente depuis La Fusion Ethereum.
+
+## Prérequis {#prerequisites}
+
+Pour mieux comprendre cette page, nous vous recommandons de lire d'abord le [consensus de preuve de travail](/developers/docs/consensus-mechanisms/pow), [le minage](/developers/docs/consensus-mechanisms/pow/mining), et [les algorithmes de minage](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms).
+
+## Dagger-Hashimoto {#dagger-hashimoto}
+
+Dagger-Hashimoto vise à satisfaire deux objectifs :
+
+1. **Résistance aux ASIC** : l'avantage de créer du matériel spécialisé pour l'algorithme devrait être aussi faible que possible
+2. **Vérification possible par les clients allégés** : un bloc doit être vérifié efficacement par un client allégé.
+
+Avec une modification supplémentaire, et si cela vous intéresse, nous vous spécifierons également comment réaliser un troisième objectif mais au prix d'une complexité supplémentaire :
+
+**Le stockage de chaîne complète** : le minage doit nécessiter un stockage de l'état de la blockchain complète (en raison de la structure irrégulière de la tentative d'état d'Ethereum, nous nous attendons à ce qu'un certain raccourcissement soit possible, en particulier pour certains contrats souvent utilisés tout en minimisant ceci).
+
+## Génération DAG {#dag-generation}
+
+Le code de l'algorithme sera défini ci-dessous en Python. Premièrement, nous donnons un `encode_int` pour le marquage des entiers non signés de précision spécifiés aux chaînes de caractères. L'inverse est également donné :
+
+```python
+NUM_BITS = 512
+
+def encode_int(x):
+ "Encode an integer x as a string of 64 characters using a big-endian scheme"
+ o = ''
+ for _ in range(NUM_BITS / 8):
+ o = chr(x % 256) + o
+ x //= 256
+ return o
+
+def decode_int(s):
+ "Unencode an integer x from a string using a big-endian scheme"
+ x = 0
+ for c in s:
+ x *= 256
+ x += ord(c)
+ return x
+```
+
+Nous supposons maintenant que `sha3` est une fonction qui prend un entier et donne un entier, et `dbl_sha3` est une fonction double-sha3 ; si vous convertissez ce code de référence dans une utilisation d'implémentation :
+
+```python
+from pyethereum import utils
+def sha3(x):
+ if isinstance(x, (int, long)):
+ x = encode_int(x)
+ return decode_int(utils.sha3(x))
+
+def dbl_sha3(x):
+ if isinstance(x, (int, long)):
+ x = encode_int(x)
+ return decode_int(utils.sha3(utils.sha3(x)))
+```
+
+### Paramètres {#parameters}
+
+Les paramètres utilisés pour l'algorithme sont :
+
+```python
+SAFE_PRIME_512 = 2**512 - 38117 # Largest Safe Prime less than 2**512
+
+params = {
+ "n": 4000055296 * 8 // NUM_BITS, # Size of the dataset (4 Gigabytes); MUST BE MULTIPLE OF 65536
+ "n_inc": 65536, # Increment in value of n per period; MUST BE MULTIPLE OF 65536
+ # with epochtime=20000 gives 882 MB growth per year
+ "cache_size": 2500, # Size of the light client's cache (can be chosen by light
+ # client; not part of the algo spec)
+ "diff": 2**14, # Difficulty (adjusted during block evaluation)
+ "epochtime": 100000, # Length of an epoch in blocks (how often the dataset is updated)
+ "k": 1, # Number of parents of a node
+ "w": w, # Used for modular exponentiation hashing
+ "accesses": 200, # Number of dataset accesses during hashimoto
+ "P": SAFE_PRIME_512 # Safe Prime for hashing and random number generation
+}
+```
+
+Dans ce cas `P` est une prime choisie telle que `log₂(P)` soit juste un peu en deçà de 512, qui correspond aux 512 bits que nous utilisons pour représenter nos nombres. Notez que seule la dernière moitié du DAG doit être stockée, ainsi le besoin de mémoire commence de fait à 1 Go et augmente de 441 Mo par an.
+
+### Construction graphique Dagger {#dagger-graph-building}
+
+La construction graphique Dagger primitive est définie comme suit :
+
+```python
+def produce_dag(params, seed, length):
+ P = params["P"]
+ picker = init = pow(sha3(seed), params["w"], P)
+ o = [init]
+ for i in range(1, length):
+ x = picker = (picker * init) % P
+ for _ in range(params["k"]):
+ x ^= o[x % i]
+ o.append(pow(x, params["w"], P))
+ return o
+```
+
+Essentiellement, cela commence par un graphique en tant que nœud unique, `sha3(seed)`, puis, à partir de ce stade, comment l'ajout séquentiel sur d'autres nœuds basés sur des nœuds précédents aléatoires. Lorsqu'un nouveau nœud est créé, la puissance modulaire de la graine est calculée pour sélectionner aléatoirement des indices inférieurs à `i` (en utilisant `x % i` ci-dessus), et les valeurs des noeuds au regard de ces indices sont utilisées dans un calcul pour générer une nouvelle valeur pour `x`, qui est ensuite alimentée par une fonction de preuve de travail sommaire (basée sur XOR) pour finalement générer la valeur du graphique à l'indice `i`. La raison d'être de cette conception particulière est de forcer l'accès séquentiel du DAG ; la valeur suivante du DAG qui sera accessible ne peut pas être déterminée tant que la valeur courante n'est pas connue. Enfin, l’exponentiation modulaire permet de hacher le résultat.
+
+Cet algorithme repose sur plusieurs résultats de la théorie des nombres. Consultez l'annexe ci-dessous à des fins de discussion.
+
+## Évaluation du client allégé {#light-client-evaluation}
+
+La construction du graphique ci-dessus vise à permettre à chaque nœud du graphique d'être reconstruit en calculant une sous-arborescence d'un petit nombre de nœuds et en ne nécessitant qu'une petite quantité de mémoire auxiliaire. Notez qu'avec k=1, la sous-arborescence n'est qu'une chaîne de valeurs allant jusqu'au premier élément du DAG.
+
+Pour que le DAG fonctionne, la fonction de calcul du client allégé est la suivante :
+
+```python
+def quick_calc(params, seed, p):
+ w, P = params["w"], params["P"]
+ cache = {}
+
+ def quick_calc_cached(p):
+ if p in cache:
+ pass
+ elif p == 0:
+ cache[p] = pow(sha3(seed), w, P)
+ else:
+ x = pow(sha3(seed), (p + 1) * w, P)
+ for _ in range(params["k"]):
+ x ^= quick_calc_cached(x % p)
+ cache[p] = pow(x, w, P)
+ return cache[p]
+
+ return quick_calc_cached(p)
+```
+
+Il s'agit essentiellement d'une réécriture de l'algorithme ci-dessus qui supprime la boucle de calcul des valeurs pour l'ensemble du DAG et remplace la précédente recherche du nœud par un appel récursif ou une recherche de cache. Notez que pour `k=1` le cache n'est pas nécessaire, bien qu'une optimisation supplémentaire calcule au préalable en fait les premiers milliers de valeurs du DAG et conserve cela en tant que cache statique pour les calculs ; voir l'annexe pour une implémentation de code de cette fonction.
+
+## Double tampon de DAG {#double-buffer}
+
+Dans un client complet, un [_double tampon_](https://wikipedia.org/wiki/Multiple_buffering) de 2 DAG produit par la formule ci-dessus est utilisé. L'idée est que les DAG produisent tous les nombres de blocs `epochtime` selon les paramètres ci-dessus. Au lieu d'utiliser le dernier DAG produit, le client utilise le précédent. L'avantage est qu'il permet aux DAG d'être remplacés au fil du temps sans avoir besoin d'incorporer une étape où les mineurs devraient soudainement recalculer toutes les données. Sinon, il existe un risque de ralentissement brutal et temporaire du traitement en chaîne à intervalles réguliers et d'augmentation spectaculaire de la centralisation. Ainsi, il existe un risque d'attaques de 51% au cours de ces quelques minutes avant que toutes les données ne soient recalculées.
+
+L'algorithme utilisé pour générer l'ensemble des DAG utilisés pour calculer le travail d'un bloc est le suivant :
+
+```python
+def get_prevhash(n):
+ from pyethereum.blocks import GENESIS_PREVHASH
+ from pyethereum import chain_manager
+ if num <= 0:
+ return hash_to_int(GENESIS_PREVHASH)
+ else:
+ prevhash = chain_manager.index.get_block_by_number(n - 1)
+ return decode_int(prevhash)
+
+def get_seedset(params, block):
+ seedset = {}
+ seedset["back_number"] = block.number - (block.number % params["epochtime"])
+ seedset["back_hash"] = get_prevhash(seedset["back_number"])
+ seedset["front_number"] = max(seedset["back_number"] - params["epochtime"], 0)
+ seedset["front_hash"] = get_prevhash(seedset["front_number"])
+ return seedset
+
+def get_dagsize(params, block):
+ return params["n"] + (block.number // params["epochtime"]) * params["n_inc"]
+
+def get_daggerset(params, block):
+ dagsz = get_dagsize(params, block)
+ seedset = get_seedset(params, block)
+ if seedset["front_hash"] <= 0:
+ # No back buffer is possible, just make front buffer
+ return {"front": {"dag": produce_dag(params, seedset["front_hash"], dagsz),
+ "block_number": 0}}
+ else:
+ return {"front": {"dag": produce_dag(params, seedset["front_hash"], dagsz),
+ "block_number": seedset["front_number"]},
+ "back": {"dag": produce_dag(params, seedset["back_hash"], dagsz),
+ "block_number": seedset["back_number"]}}
+```
+
+## Hashimoto {#hashimoto}
+
+L'idée derrière le Hashimoto original est d'utiliser la blockchain comme jeu de données, effectuant un calcul qui sélectionne N indices de la blockchain, rassemble les transactions sur ces indices, exécute un XOR de ces données, et retourne le hachage du résultat. L'algorithme original de Thaddeus Dryja, traduit en Python pour la cohérence, est le suivant :
+
+```python
+def orig_hashimoto(prev_hash, merkle_root, list_of_transactions, nonce):
+ hash_output_A = sha256(prev_hash + merkle_root + nonce)
+ txid_mix = 0
+ for i in range(64):
+ shifted_A = hash_output_A >> i
+ transaction = shifted_A % len(list_of_transactions)
+ txid_mix ^= list_of_transactions[transaction] << i
+ return txid_max ^ (nonce << 192)
+```
+
+Malheureusement, bien que Hashimoto soit considéré comme de la RAM en dur, il repose sur l'arithmétique 256-bit, qui présente des frais supplémentaires de calcul considérables. Cependant, Dagger-Hashimoto n'utilise que les 64 bits les moins significatifs lors de l'indexation de son jeu de données pour résoudre ce problème.
+
+```python
+def hashimoto(dag, dagsize, params, header, nonce):
+ m = dagsize / 2
+ mix = sha3(encode_int(nonce) + header)
+ for _ in range(params["accesses"]):
+ mix ^= dag[m + (mix % 2**64) % m]
+ return dbl_sha3(mix)
+```
+
+L'utilisation du double SHA3 permet à un formulaire de zéro donnée, une pré-vérification quasi instantanée, vérifiant uniquement qu'une valeur intermédiaire correcte a été fournie. Cette couche extérieure de preuve de travail est très favorable aux ASIC et assez faible, mais existe pour rendre les attaques DDoS encore plus difficiles puisque cette petite quantité de travail doit être réalisée pour produire un bloc qui ne sera pas immédiatement rejeté. Voici la version client allégé :
+
+```python
+def quick_hashimoto(seed, dagsize, params, header, nonce):
+ m = dagsize // 2
+ mix = sha3(nonce + header)
+ for _ in range(params["accesses"]):
+ mix ^= quick_calc(params, seed, m + (mix % 2**64) % m)
+ return dbl_sha3(mix)
+```
+
+## Minage et vérification {#mining-and-verifying}
+
+Maintenant, mettons tout cela ensemble dans l'algorithme de minage :
+
+```python
+def mine(daggerset, params, block):
+ from random import randint
+ nonce = randint(0, 2**64)
+ while 1:
+ result = hashimoto(daggerset, get_dagsize(params, block),
+ params, decode_int(block.prevhash), nonce)
+ if result * params["diff"] < 2**256:
+ break
+ nonce += 1
+ if nonce >= 2**64:
+ nonce = 0
+ return nonce
+```
+
+Voici l'algorithme de vérification :
+
+```python
+def verify(daggerset, params, block, nonce):
+ result = hashimoto(daggerset, get_dagsize(params, block),
+ params, decode_int(block.prevhash), nonce)
+ return result * params["diff"] < 2**256
+```
+
+Vérification conviviale du client allégé :
+
+```python
+def light_verify(params, header, nonce):
+ seedset = get_seedset(params, block)
+ result = quick_hashimoto(seedset["front_hash"], get_dagsize(params, block),
+ params, decode_int(block.prevhash), nonce)
+ return result * params["diff"] < 2**256
+```
+
+Notez également que Dagger-Hashimoto impose des exigences supplémentaires à l'en-tête du bloc:
+
+- Pour que la vérification de deux couches fonctionne, un en-tête de bloc doit avoir à la fois la valeur nonce et la valeur moyenne pré-sha3
+- Quelque part, un en-tête de bloc doit stocker la sha3 de l'actuel ensemble de données
+
+## Complément d'information {#further-reading}
+
+_Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
+
+## Annexe {#appendix}
+
+Comme mentionné ci-dessus, le RNG utilisé pour la génération de DAG repose sur des résultats tirés de la théorie des nombres. Premièrement, nous fournissons l'assurance que le RNG Lehmer qui est la base de la variable `picker` dispose d'une période longue. Deuxièmement, nous montrons que `pow(x,3,P)` ne fera pas correspondre `x` à `1` ou `P-1` fourni `x ∈ [2,P-2]` pour commencer. Enfin, nous montrons que `pow(x,3,P)` a un faible taux de collision lorsqu'il est traité comme une fonction de hachage.
+
+### Générateur de nombre aléatoire Lehmer {#lehmer-random-number}
+
+Alors que la fonction `produce_dag` n'a pas besoin de produire des nombres aléatoires impartiaux, une menace potentielle est que `seed**i % P` prenne uniquement une poignée de valeurs. Cela pourrait être un avantage pour les mineurs qui reconnaissent le modèle par rapport à ceux qui ne le font pas.
+
+Pour éviter cela, un résultat de la théorie du nombre est exercé. Un [_Safe Prime_](https://en.wikipedia.org/wiki/Safe_prime) est défini comme un premier `P` tel que `(P-1)/2` est également un nombre premier. L'_ordre_ d'un membre `x` du [groupe multiplicateur](https://en.wikipedia.org/wiki/Multiplicative_group_of_integers_modulo_n) `ℤ/nℤ` est défini pour être le minimum `m` tel que xᵐ mod P ≡ 1
+Compte tenu de ces définitions, nous avons :
+
+> Observation 1. Laisser `x` être un membre du groupe multiplicateur `ℤ/Pℤ` pour un nombre premier sûr `P`. Si `x mod P ≠ 1 mod P` et `x mod P ≠ P-1 mod P`, alors l'ordre de `x` est soit `P-1` soit `(P-1)/2`.
+
+_Preuve_. Puisque `P` est un nombre premier sécurisé, puis par \[Lagrange's Theorem\]\[lagrange\] nous trouvons que l'ordre de `x` est soit `1`, `2`, `(P-1)/2`, soit `P-1`.
+
+L'ordre de `x` ne peut pas être `1`, puisque suivant le petit théorème de Fermat, nous avons :
+
+xP-1 mod P ≡ 1
+
+C'est pourquoi `x` doit être une identité multiplicative de `ℤ/nℤ`, ce qui est unique. Puisque nous supposons que `x ≠ 1` par hypothèse, ce n'est pas possible.
+
+L'ordre de `x` ne peut pas être `2` sauf si `x = P-1`, car cela violerait le principe que `P` soit un nombre premier.
+
+À partir de la proposition ci-dessus, nous pouvons reconnaître que l'itération `(picker * init) % P` aura une longueur de cycle d'au moins `(P-1)/2`. Ceci est dû au fait que nous avons sélectionné `P` pour être un nombre premier sûr approximativement égal à une puissance supérieure de deux, et `init` est dans l'intervalle `[2,2**256+1]`. Étant donné la magnitude de `P`, nous ne devrions jamais nous attendre à un cycle d'exponentiation modulaire.
+
+Lorsque nous assignons la première cellule dans le DAG (la variable étiquetée `init`), nous calculons `pow(sha3(seed) + 2, 3, P)`. À première vue, cela ne garantit pas que le résultat n'est ni `1` ni `P-1`. Cependant, puisque `P-1` est un nombre premier sûr, nous émettons l'hypothèse supplémentaire suivante, qui est un corollaire de l'observation 1 :
+
+> Observation 2. Laissons `x` être membre du groupe multiplicateur `ℤ/Pℤ` pour un nombre premier sûr `P`, et laissons `w` être un nombre naturel. Si `x mod P ≠ 1 mod P` et `x mod P ≠ P-1 mod P`, tout comme `w mod P ≠ P-1 mod P` et `w mod P ≠ 0 mod P`, alors `xʷ mod P ≠ 1 mod P` et `xʷ mod P ≠ P-1 mod P`
+
+### Exponentiation modulaire comme fonction de hachage {#modular-exponentiation}
+
+Pour certaines valeurs de `P` et `w`, la fonction `pow(x, w, P)` peut présenter de nombreuses collisions. Par exemple, `pow(x,9,19)` ne prend que les valeurs `{1,18}`.
+
+Étant donné que `P` est un nombre premier, alors un `w` approprié pour une fonction de hachage d'exponentiation modulaire peut être choisi en utilisant le résultat suivant :
+
+> Observation 3. Laissez `P` être un nombre premier ; `w` et `P-1` sont relativement premiers si et seulement si pour tous les `a` et `b` en `ℤ/Pℤ` :
+>
+>
+> `aʷ mod P ≡ bʷ mod P` si et seulement si `a mod P ≡ b mod P`
+>
+
+Ainsi, étant donné que `P` est un nombre premier et que `w` est relativement premier à `P-1`, nous avons `|{pow(x, w, P) : x ∈ ℤ}| = P`, ce qui implique que la fonction de hachage a le taux de collision minimal possible.
+
+Dans le cas spécial ou `P` est un nombre premier sûr comme nous l'avons sélectionné, alors `P-1` n'aura que les facteurs 1, 2, `(P-1)/2` et `P-1`. Puisque `P` > 7, nous savons que 3 est relativement premier à `P-1`, donc `w=3` satisfait la proposition ci-dessus.
+
+## Algorithme d'évaluation basé sur un cache plus efficace {#cache-based-evaluation}
+
+```python
+def quick_calc(params, seed, p):
+ cache = produce_dag(params, seed, params["cache_size"])
+ return quick_calc_cached(cache, params, p)
+
+def quick_calc_cached(cache, params, p):
+ P = params["P"]
+ if p < len(cache):
+ return cache[p]
+ else:
+ x = pow(cache[0], p + 1, P)
+ for _ in range(params["k"]):
+ x ^= quick_calc_cached(cache, params, x % p)
+ return pow(x, params["w"], P)
+
+def quick_hashimoto(seed, dagsize, params, header, nonce):
+ cache = produce_dag(params, seed, params["cache_size"])
+ return quick_hashimoto_cached(cache, dagsize, params, header, nonce)
+
+def quick_hashimoto_cached(cache, dagsize, params, header, nonce):
+ m = dagsize // 2
+ mask = 2**64 - 1
+ mix = sha3(encode_int(nonce) + header)
+ for _ in range(params["accesses"]):
+ mix ^= quick_calc_cached(cache, params, m + (mix & mask) % m)
+ return dbl_sha3(mix)
+```
diff --git a/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
new file mode 100644
index 00000000000..e31290eef6a
--- /dev/null
+++ b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
@@ -0,0 +1,1014 @@
+---
+title: Ethash
+description: Un aperçu en détail de l'algorithme Ethash.
+lang: fr
+---
+
+
+ Ethash était l'algorithme de minage par preuve de travail d'Ethereum. La preuve de travail est maintenant **arrêtée entièrement** et Ethereum est maintenant sécurisé en utilisant la preuve d'enjeu à la place. En savoir plus sur La Fusion, la preuve d'enjeu et la mise en jeu. Cette page n'a qu'un intérêt historique !
+
+
+[Ethash](https://github.com/ethereum/wiki/wiki/Ethash) est une version modifiée de l'algorithme [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining-algorithms/dagger-hashimoto). La preuve de travail d'Ethash est une [mémoire solide](https://wikipedia.org/wiki/Memory-hard_function), qui était censée rendre l'algorithme ASIC plus résistant. Les Ethash ASIC ont finalement été développés, mais le minage via GPU restait encore une option viable jusqu’à ce que la preuve de travail soit désactivée. Ethash est toujours utilisé pour miner d'autres jetons sur des réseaux autres qu'Ethereum fonctionnant avec la preuve de travail.
+
+## Comment fonctionne Ethash ? {#how-does-ethash-work}
+
+La complexité de la mémoire est obtenue avec un algorithme de preuve de travail qui nécessite de choisir des sous-ensembles d'une ressource donnée dépendant de l'en-tête du nonce et du bloc. Cette ressource (quelques gigaoctets de taille) est appelée DAG. Le DAG change tous les 30 000 blocs, une fenêtre de 125 heures appelée une époque (soit environ 5,2 jours) et prend un certain temps à se générer. Comme le DAG ne dépend que de la taille du bloc, il peut être pré-généré, mais si ce n'est pas le cas, le client doit attendre la fin de ce processus pour produire un bloc. Si les clients ne génèrent pas et ne mettent pas en cache les DAG à l'avance, le réseau peut rencontrer un retard dans la création de blocs pour chaque transition d'epoch. Notez que le DAG n'a pas besoin d'être généré pour vérifier la preuve de travail essentiellement en permettant la vérification à la fois avec un CPU lent et avec une mémoire réduite.
+
+Le parcours habituel de l'algorithme est le suivant :
+
+1. Il existe une **graine** qui peut être calculée pour chaque bloc en scannant les en-têtes de bloc jusqu'à ce point.
+2. À partir de la graine, on peut calculer un **cache pseudoaléatoire de 16 Mo**. Les clients légers stockent le cache.
+3. À partir du cache, nous pouvons générer un **jeu de données 1 Go**, avec la propriété que chaque élément du jeu de données ne dépend que d'un petit nombre d'éléments du cache. Les clients et les mineurs au complet stockent le jeu de données. Le jeu de données croît linéairement avec le temps.
+4. Le minage consiste à saisir des tranches aléatoires de l'ensemble des données et à les hacher ensemble. La vérification peut être faite avec peu de mémoire en utilisant le cache pour régénérer les morceaux spécifiques du jeu de données dont vous avez besoin, ainsi, vous avez uniquement besoin de stocker le cache.
+
+Le grand ensemble de données est mis à jour une fois tous les 30 000 blocs, de sorte que la grande majorité des efforts d'un mineur sera de lire l'ensemble des données, et non d'y apporter des modifications.
+
+## Définitions {#definitions}
+
+Nous utilisons les définitions suivantes :
+
+```
+WORD_BYTES = 4 # bytes in word
+DATASET_BYTES_INIT = 2**30 # bytes in dataset at genesis
+DATASET_BYTES_GROWTH = 2**23 # dataset growth per epoch
+CACHE_BYTES_INIT = 2**24 # bytes in cache at genesis
+CACHE_BYTES_GROWTH = 2**17 # cache growth per epoch
+CACHE_MULTIPLIER=1024 # Size of the DAG relative to the cache
+EPOCH_LENGTH = 30000 # blocks per epoch
+MIX_BYTES = 128 # width of mix
+HASH_BYTES = 64 # hash length in bytes
+DATASET_PARENTS = 256 # number of parents of each dataset element
+CACHE_ROUNDS = 3 # number of rounds in cache production
+ACCESSES = 64 # number of accesses in hashimoto loop
+```
+
+### L'utilisation de 'SHA3' {#sha3}
+
+Le développement d'Ethereum a coïncidé avec le développement de la norme SHA3, et le processus de normes a réalisé un changement tardif dans le remplissage de l'algorithme de hachage finalisé de sorte que les hachages Ethereum "sha3_256" et "sha3_512" ne soient pas des hashs sha3 standard, mais une variante appelée souvent « Keccak-256 » et « Keccak-512 » dans d'autres contextes. Voir la discussion en exemple [ici](https://eips.ethereum.org/EIPS-1803), [ici](http://ethereum.stackexchange.com/questions/550/which-cryptographic-hash-function-does-ethereum-use), ou [ici](http://bitcoin.stackexchange.com/questions/42055/what-is-the-approach-to-calculate-an-ethereum-address-from-a-256-bit-private-key/42057#42057).
+
+Veuillez garder cela à l'esprit, car les hachages « sha3 » sont mentionnés dans la description de l'algorithme ci-dessous.
+
+## Paramètres {#parameters}
+
+Les paramètres du cache et du jeu de données d'Ethash dépendent du numéro du bloc. La taille du cache et de la taille de l'ensemble des données augmentent linéairement ; cependant, nous prenons toujours le nombre premier le plus haut en dessous du seuil de croissance linéaire afin de réduire le risque de régularités accidentelles conduisant à un comportement cyclique.
+
+```python
+def get_cache_size(block_number):
+ sz = CACHE_BYTES_INIT + CACHE_BYTES_GROWTH * (block_number // EPOCH_LENGTH)
+ sz -= HASH_BYTES
+ while not isprime(sz / HASH_BYTES):
+ sz -= 2 * HASH_BYTES
+ return sz
+
+def get_full_size(block_number):
+ sz = DATASET_BYTES_INIT + DATASET_BYTES_GROWTH * (block_number // EPOCH_LENGTH)
+ sz -= MIX_BYTES
+ while not isprime(sz / MIX_BYTES):
+ sz -= 2 * MIX_BYTES
+ return sz
+```
+
+Les tables de jeu de données et les valeurs de taille de cache sont fournies dans l'annexe.
+
+## Génération de cache {#cache-generation}
+
+Maintenant, nous spécifions la fonction pour produire un cache :
+
+```python
+def mkcache(cache_size, seed):
+ n = cache_size // HASH_BYTES
+
+ # Sequentially produce the initial dataset
+ o = [sha3_512(seed)]
+ for i in range(1, n):
+ o.append(sha3_512(o[-1]))
+
+ # Use a low-round version of randmemohash
+ for _ in range(CACHE_ROUNDS):
+ for i in range(n):
+ v = o[i][0] % n
+ o[i] = sha3_512(map(xor, o[(i-1+n) % n], o[v]))
+
+ return o
+```
+
+Le processus de production du cache implique d'abord le remplissage séquentiel de 32 Mo de mémoire, effectuant alors deux passes de l'algorithme _RandMemoHash_ de Sergio Demian Lerner à partir de [_Strict Memory Hashing Functions_ (2014)](http://www.hashcash.org/papers/memohash.pdf). La sortie est un ensemble de valeurs de 524288 de 64 octets.
+
+## Fonction d'agrégation de données {#date-aggregation-function}
+
+Nous utilisons un algorithme inspiré du [hachage FNV](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function) dans certains cas comme un substitut non associatif pour XOR. Notez que nous multiplions le premier par l'entrée 32 bits, contrairement à la spécification FNV-1 qui multiplie le premier avec un octet à son tour.
+
+```python
+FNV_PRIME = 0x01000193
+
+def fnv(v1, v2):
+ return ((v1 * FNV_PRIME) ^ v2) % 2**32
+```
+
+Veuillez noter que même le papier jaune spécifie fnv comme v1\*(FNV_PRIME ^ v2), toutes les implémentations actuelles utilisent systématiquement la définition ci-dessus.
+
+## Calcul du jeu de données complet {#full-dataset-calculation}
+
+Chaque élément de 64 octets dans le jeu de données complet de 1 Go est calculé comme suit :
+
+```python
+def calc_dataset_item(cache, i):
+ n = len(cache)
+ r = HASH_BYTES // WORD_BYTES
+ # initialize the mix
+ mix = copy.copy(cache[i % n])
+ mix[0] ^= i
+ mix = sha3_512(mix)
+ # fnv it with a lot of random cache nodes based on i
+ for j in range(DATASET_PARENTS):
+ cache_index = fnv(i ^ j, mix[j % r])
+ mix = map(fnv, mix, cache[cache_index % n])
+ return sha3_512(mix)
+```
+
+Essentiellement, nous combinons des données à partir de 256 nœuds de cache sélectionnés de façon pseudologique, et de hachage pour calculer le noeud de l'ensemble de données. L'ensemble du jeu de données est ensuite généré par :
+
+```python
+def calc_dataset(full_size, cache):
+ return [calc_dataset_item(cache, i) for i in range(full_size // HASH_BYTES)]
+```
+
+## Boucle principale {#main-loop}
+
+Maintenant, nous spécifions la boucle principale « hashimoto », où nous agrégeons les données du jeu de données complet, afin de produire notre valeur finale pour un en-tête et un nonce. Dans le code ci-dessous, `header` représente le _hachage_ SHA3-256 de la représentation RLP d'un en-tête de bloc _tronqué_, qui est d'un en-tête excluant les champs **mixHash** et **nonce**. `nonce` constitue les huit octets d'un entier 64 bits non signé dans un ordre big-endian. Ainsi `nonce[::-1]` est la représentation de huit octets little-endian de cette valeur :
+
+```python
+def hashimoto(header, nonce, full_size, dataset_lookup):
+ n = full_size / HASH_BYTES
+ w = MIX_BYTES // WORD_BYTES
+ mixhashes = MIX_BYTES / HASH_BYTES
+ # combine header+nonce into a 64 byte seed
+ s = sha3_512(header + nonce[::-1])
+ # start the mix with replicated s
+ mix = []
+ for _ in range(MIX_BYTES / HASH_BYTES):
+ mix.extend(s)
+ # mix in random dataset nodes
+ for i in range(ACCESSES):
+ p = fnv(i ^ s[0], mix[i % w]) % (n // mixhashes) * mixhashes
+ newdata = []
+ for j in range(MIX_BYTES / HASH_BYTES):
+ newdata.extend(dataset_lookup(p + j))
+ mix = map(fnv, mix, newdata)
+ # compress mix
+ cmix = []
+ for i in range(0, len(mix), 4):
+ cmix.append(fnv(fnv(fnv(mix[i], mix[i+1]), mix[i+2]), mix[i+3]))
+ return {
+ "mix digest": serialize_hash(cmix),
+ "result": serialize_hash(sha3_256(s+cmix))
+ }
+
+def hashimoto_light(full_size, cache, header, nonce):
+ return hashimoto(header, nonce, full_size, lambda x: calc_dataset_item(cache, x))
+
+def hashimoto_full(full_size, dataset, header, nonce):
+ return hashimoto(header, nonce, full_size, lambda x: dataset[x])
+```
+
+Essentiellement, nous maintenons un « mix » de 128 octets de taille, et récupérons séquentiellement 128 octets du jeu de données complet et utilisons la fonction `fnv` à des fins de combinaison avec le mix. 128 octets d'accès séquentiel sont utilisés de sorte que chaque tour de l'algorithme récupère toujours une page complète de la RAM. Minimiser le tampon de lecture de la traduction loupe ce que l'ASIC serait théoriquement en mesure d'éviter.
+
+Si la sortie de cet algorithme est en dessous de la cible souhaitée, alors le nonce est valide. Notez que l'application supplémentaire de `sha3_256` à la fin garantit qu'il existe un nonce intermédiaire qui peut être fourni pour prouver qu'au moins une petite quantité de travail a été faite ; cette vérification externe rapide de PoW peut être utilisée à des fins anti-DDoS. Cela sert également à fournir une assurance statistique que le résultat est un nombre non biaisé de 256 bits.
+
+## Minage {#mining}
+
+L'algorithme de minage est défini comme suit :
+
+```python
+def mine(full_size, dataset, header, difficulty):
+ # zero-pad target to compare with hash on the same digit
+ target = zpad(encode_int(2**256 // difficulty), 64)[::-1]
+ from random import randint
+ nonce = randint(0, 2**64)
+ while hashimoto_full(full_size, dataset, header, nonce) > target:
+ nonce = (nonce + 1) % 2**64
+ return nonce
+```
+
+## Définition du hachage de la graine {#seed-hash}
+
+Afin de calculer le hachage de la graine qui serait utilisé pour miner au-dessus d'un bloc donné, nous utilisons l'algorithme suivant :
+
+```python
+ def get_seedhash(block):
+ s = '\x00' * 32
+ for i in range(block.number // EPOCH_LENGTH):
+ s = serialize_hash(sha3_256(s))
+ return s
+```
+
+Notez que pour un minage et une vérification en douceur, nous recommandons de calculer au préalable les futures semences et les jeux de données dans un fil séparé.
+
+## Complément d'information {#further-reading}
+
+_Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
+
+## Annexe {#appendix}
+
+Le code suivant devrait être préfixé si vous souhaitez exécuter la spécification python ci-dessus en tant que code.
+
+```python
+import sha3, copy
+
+# Assumes little endian bit ordering (same as Intel architectures)
+def decode_int(s):
+ return int(s[::-1].encode('hex'), 16) if s else 0
+
+def encode_int(s):
+ a = "%x" % s
+ return '' if s == 0 else ('0' * (len(a) % 2) + a).decode('hex')[::-1]
+
+def zpad(s, length):
+ return s + '\x00' * max(0, length - len(s))
+
+def serialize_hash(h):
+ return ''.join([zpad(encode_int(x), 4) for x in h])
+
+def deserialize_hash(h):
+ return [decode_int(h[i:i+WORD_BYTES]) for i in range(0, len(h), WORD_BYTES)]
+
+def hash_words(h, sz, x):
+ if isinstance(x, list):
+ x = serialize_hash(x)
+ y = h(x)
+ return deserialize_hash(y)
+
+def serialize_cache(ds):
+ return ''.join([serialize_hash(h) for h in ds])
+
+serialize_dataset = serialize_cache
+
+# sha3 hash function, outputs 64 bytes
+def sha3_512(x):
+ return hash_words(lambda v: sha3.sha3_512(v).digest(), 64, x)
+
+def sha3_256(x):
+ return hash_words(lambda v: sha3.sha3_256(v).digest(), 32, x)
+
+def xor(a, b):
+ return a ^ b
+
+def isprime(x):
+ for i in range(2, int(x**0.5)):
+ if x % i == 0:
+ return False
+ return True
+```
+
+### Tailles des données {#data-sizes}
+
+Les tables de recherche suivantes fournissent environ 2048 epochs tabulées de la taille des données et de la taille des caches.
+
+```python
+def get_datasize(block_number):
+ return data_sizes[block_number // EPOCH_LENGTH]
+
+def get_cachesize(block_number):
+ return cache_sizes[block_number // EPOCH_LENGTH]
+
+data_sizes = [
+1073739904, 1082130304, 1090514816, 1098906752, 1107293056,
+1115684224, 1124070016, 1132461952, 1140849536, 1149232768,
+1157627776, 1166013824, 1174404736, 1182786944, 1191180416,
+1199568512, 1207958912, 1216345216, 1224732032, 1233124736,
+1241513344, 1249902464, 1258290304, 1266673792, 1275067264,
+1283453312, 1291844992, 1300234112, 1308619904, 1317010048,
+1325397376, 1333787776, 1342176128, 1350561664, 1358954368,
+1367339392, 1375731584, 1384118144, 1392507008, 1400897408,
+1409284736, 1417673344, 1426062464, 1434451072, 1442839168,
+1451229056, 1459615616, 1468006016, 1476394112, 1484782976,
+1493171584, 1501559168, 1509948032, 1518337664, 1526726528,
+1535114624, 1543503488, 1551892096, 1560278656, 1568669056,
+1577056384, 1585446272, 1593831296, 1602219392, 1610610304,
+1619000192, 1627386752, 1635773824, 1644164224, 1652555648,
+1660943488, 1669332608, 1677721216, 1686109312, 1694497664,
+1702886272, 1711274624, 1719661184, 1728047744, 1736434816,
+1744829056, 1753218944, 1761606272, 1769995904, 1778382464,
+1786772864, 1795157888, 1803550592, 1811937664, 1820327552,
+1828711552, 1837102976, 1845488768, 1853879936, 1862269312,
+1870656896, 1879048064, 1887431552, 1895825024, 1904212096,
+1912601216, 1920988544, 1929379456, 1937765504, 1946156672,
+1954543232, 1962932096, 1971321728, 1979707264, 1988093056,
+1996487552, 2004874624, 2013262208, 2021653888, 2030039936,
+2038430848, 2046819968, 2055208576, 2063596672, 2071981952,
+2080373632, 2088762752, 2097149056, 2105539712, 2113928576,
+2122315136, 2130700672, 2139092608, 2147483264, 2155872128,
+2164257664, 2172642176, 2181035392, 2189426048, 2197814912,
+2206203008, 2214587264, 2222979712, 2231367808, 2239758208,
+2248145024, 2256527744, 2264922752, 2273312128, 2281701248,
+2290086272, 2298476672, 2306867072, 2315251072, 2323639168,
+2332032128, 2340420224, 2348808064, 2357196416, 2365580416,
+2373966976, 2382363008, 2390748544, 2399139968, 2407530368,
+2415918976, 2424307328, 2432695424, 2441084288, 2449472384,
+2457861248, 2466247808, 2474637184, 2483026816, 2491414144,
+2499803776, 2508191872, 2516582272, 2524970368, 2533359232,
+2541743488, 2550134144, 2558525056, 2566913408, 2575301504,
+2583686528, 2592073856, 2600467328, 2608856192, 2617240448,
+2625631616, 2634022016, 2642407552, 2650796416, 2659188352,
+2667574912, 2675965312, 2684352896, 2692738688, 2701130624,
+2709518464, 2717907328, 2726293376, 2734685056, 2743073152,
+2751462016, 2759851648, 2768232832, 2776625536, 2785017728,
+2793401984, 2801794432, 2810182016, 2818571648, 2826959488,
+2835349376, 2843734144, 2852121472, 2860514432, 2868900992,
+2877286784, 2885676928, 2894069632, 2902451584, 2910843008,
+2919234688, 2927622784, 2936011648, 2944400768, 2952789376,
+2961177728, 2969565568, 2977951616, 2986338944, 2994731392,
+3003120256, 3011508352, 3019895936, 3028287104, 3036675968,
+3045063808, 3053452928, 3061837696, 3070228352, 3078615424,
+3087003776, 3095394944, 3103782272, 3112173184, 3120562048,
+3128944768, 3137339264, 3145725056, 3154109312, 3162505088,
+3170893184, 3179280256, 3187669376, 3196056704, 3204445568,
+3212836736, 3221224064, 3229612928, 3238002304, 3246391168,
+3254778496, 3263165824, 3271556224, 3279944576, 3288332416,
+3296719232, 3305110912, 3313500032, 3321887104, 3330273152,
+3338658944, 3347053184, 3355440512, 3363827072, 3372220288,
+3380608384, 3388997504, 3397384576, 3405774208, 3414163072,
+3422551936, 3430937984, 3439328384, 3447714176, 3456104576,
+3464493952, 3472883584, 3481268864, 3489655168, 3498048896,
+3506434432, 3514826368, 3523213952, 3531603584, 3539987072,
+3548380288, 3556763264, 3565157248, 3573545344, 3581934464,
+3590324096, 3598712704, 3607098752, 3615488384, 3623877248,
+3632265856, 3640646528, 3649043584, 3657430144, 3665821568,
+3674207872, 3682597504, 3690984832, 3699367808, 3707764352,
+3716152448, 3724541056, 3732925568, 3741318016, 3749706368,
+3758091136, 3766481536, 3774872704, 3783260032, 3791650432,
+3800036224, 3808427648, 3816815488, 3825204608, 3833592704,
+3841981568, 3850370432, 3858755968, 3867147904, 3875536256,
+3883920512, 3892313728, 3900702592, 3909087872, 3917478784,
+3925868416, 3934256512, 3942645376, 3951032192, 3959422336,
+3967809152, 3976200064, 3984588416, 3992974976, 4001363584,
+4009751168, 4018141312, 4026530432, 4034911616, 4043308928,
+4051695488, 4060084352, 4068472448, 4076862848, 4085249408,
+4093640576, 4102028416, 4110413696, 4118805632, 4127194496,
+4135583104, 4143971968, 4152360832, 4160746112, 4169135744,
+4177525888, 4185912704, 4194303616, 4202691968, 4211076736,
+4219463552, 4227855488, 4236246656, 4244633728, 4253022848,
+4261412224, 4269799808, 4278184832, 4286578048, 4294962304,
+4303349632, 4311743104, 4320130432, 4328521088, 4336909184,
+4345295488, 4353687424, 4362073472, 4370458496, 4378852736,
+4387238528, 4395630208, 4404019072, 4412407424, 4420790656,
+4429182848, 4437571456, 4445962112, 4454344064, 4462738048,
+4471119232, 4479516544, 4487904128, 4496289664, 4504682368,
+4513068416, 4521459584, 4529846144, 4538232704, 4546619776,
+4555010176, 4563402112, 4571790208, 4580174464, 4588567936,
+4596957056, 4605344896, 4613734016, 4622119808, 4630511488,
+4638898816, 4647287936, 4655675264, 4664065664, 4672451968,
+4680842624, 4689231488, 4697620352, 4706007424, 4714397056,
+4722786176, 4731173248, 4739562368, 4747951744, 4756340608,
+4764727936, 4773114496, 4781504384, 4789894784, 4798283648,
+4806667648, 4815059584, 4823449472, 4831835776, 4840226176,
+4848612224, 4857003392, 4865391488, 4873780096, 4882169728,
+4890557312, 4898946944, 4907333248, 4915722368, 4924110976,
+4932499328, 4940889728, 4949276032, 4957666432, 4966054784,
+4974438016, 4982831488, 4991221376, 4999607168, 5007998848,
+5016386432, 5024763776, 5033164672, 5041544576, 5049941888,
+5058329728, 5066717056, 5075107456, 5083494272, 5091883904,
+5100273536, 5108662144, 5117048192, 5125436032, 5133827456,
+5142215296, 5150605184, 5158993024, 5167382144, 5175769472,
+5184157568, 5192543872, 5200936064, 5209324928, 5217711232,
+5226102656, 5234490496, 5242877312, 5251263872, 5259654016,
+5268040832, 5276434304, 5284819328, 5293209728, 5301598592,
+5309986688, 5318374784, 5326764416, 5335151488, 5343542144,
+5351929472, 5360319872, 5368706944, 5377096576, 5385484928,
+5393871232, 5402263424, 5410650496, 5419040384, 5427426944,
+5435816576, 5444205952, 5452594816, 5460981376, 5469367936,
+5477760896, 5486148736, 5494536832, 5502925952, 5511315328,
+5519703424, 5528089984, 5536481152, 5544869504, 5553256064,
+5561645696, 5570032768, 5578423936, 5586811264, 5595193216,
+5603585408, 5611972736, 5620366208, 5628750464, 5637143936,
+5645528192, 5653921408, 5662310272, 5670694784, 5679082624,
+5687474048, 5695864448, 5704251008, 5712641408, 5721030272,
+5729416832, 5737806208, 5746194304, 5754583936, 5762969984,
+5771358592, 5779748224, 5788137856, 5796527488, 5804911232,
+5813300608, 5821692544, 5830082176, 5838468992, 5846855552,
+5855247488, 5863636096, 5872024448, 5880411008, 5888799872,
+5897186432, 5905576832, 5913966976, 5922352768, 5930744704,
+5939132288, 5947522432, 5955911296, 5964299392, 5972688256,
+5981074304, 5989465472, 5997851008, 6006241408, 6014627968,
+6023015552, 6031408256, 6039796096, 6048185216, 6056574848,
+6064963456, 6073351808, 6081736064, 6090128768, 6098517632,
+6106906496, 6115289216, 6123680896, 6132070016, 6140459648,
+6148849024, 6157237376, 6165624704, 6174009728, 6182403712,
+6190792064, 6199176064, 6207569792, 6215952256, 6224345216,
+6232732544, 6241124224, 6249510272, 6257899136, 6266287744,
+6274676864, 6283065728, 6291454336, 6299843456, 6308232064,
+6316620928, 6325006208, 6333395584, 6341784704, 6350174848,
+6358562176, 6366951296, 6375337856, 6383729536, 6392119168,
+6400504192, 6408895616, 6417283456, 6425673344, 6434059136,
+6442444672, 6450837376, 6459223424, 6467613056, 6476004224,
+6484393088, 6492781952, 6501170048, 6509555072, 6517947008,
+6526336384, 6534725504, 6543112832, 6551500672, 6559888768,
+6568278656, 6576662912, 6585055616, 6593443456, 6601834112,
+6610219648, 6618610304, 6626999168, 6635385472, 6643777408,
+6652164224, 6660552832, 6668941952, 6677330048, 6685719424,
+6694107776, 6702493568, 6710882176, 6719274112, 6727662976,
+6736052096, 6744437632, 6752825984, 6761213824, 6769604224,
+6777993856, 6786383488, 6794770816, 6803158144, 6811549312,
+6819937664, 6828326528, 6836706176, 6845101696, 6853491328,
+6861880448, 6870269312, 6878655104, 6887046272, 6895433344,
+6903822208, 6912212864, 6920596864, 6928988288, 6937377152,
+6945764992, 6954149248, 6962544256, 6970928768, 6979317376,
+6987709312, 6996093824, 7004487296, 7012875392, 7021258624,
+7029652352, 7038038912, 7046427776, 7054818944, 7063207808,
+7071595136, 7079980928, 7088372608, 7096759424, 7105149824,
+7113536896, 7121928064, 7130315392, 7138699648, 7147092352,
+7155479168, 7163865728, 7172249984, 7180648064, 7189036672,
+7197424768, 7205810816, 7214196608, 7222589824, 7230975104,
+7239367552, 7247755904, 7256145536, 7264533376, 7272921472,
+7281308032, 7289694848, 7298088832, 7306471808, 7314864512,
+7323253888, 7331643008, 7340029568, 7348419712, 7356808832,
+7365196672, 7373585792, 7381973888, 7390362752, 7398750592,
+7407138944, 7415528576, 7423915648, 7432302208, 7440690304,
+7449080192, 7457472128, 7465860992, 7474249088, 7482635648,
+7491023744, 7499412608, 7507803008, 7516192384, 7524579968,
+7532967296, 7541358464, 7549745792, 7558134656, 7566524032,
+7574912896, 7583300992, 7591690112, 7600075136, 7608466816,
+7616854912, 7625244544, 7633629824, 7642020992, 7650410368,
+7658794112, 7667187328, 7675574912, 7683961984, 7692349568,
+7700739712, 7709130368, 7717519232, 7725905536, 7734295424,
+7742683264, 7751069056, 7759457408, 7767849088, 7776238208,
+7784626816, 7793014912, 7801405312, 7809792128, 7818179968,
+7826571136, 7834957184, 7843347328, 7851732352, 7860124544,
+7868512384, 7876902016, 7885287808, 7893679744, 7902067072,
+7910455936, 7918844288, 7927230848, 7935622784, 7944009344,
+7952400256, 7960786048, 7969176704, 7977565312, 7985953408,
+7994339968, 8002730368, 8011119488, 8019508096, 8027896192,
+8036285056, 8044674688, 8053062272, 8061448832, 8069838464,
+8078227328, 8086616704, 8095006592, 8103393664, 8111783552,
+8120171392, 8128560256, 8136949376, 8145336704, 8153726848,
+8162114944, 8170503296, 8178891904, 8187280768, 8195669632,
+8204058496, 8212444544, 8220834176, 8229222272, 8237612672,
+8246000768, 8254389376, 8262775168, 8271167104, 8279553664,
+8287944064, 8296333184, 8304715136, 8313108352, 8321497984,
+8329885568, 8338274432, 8346663296, 8355052928, 8363441536,
+8371828352, 8380217984, 8388606592, 8396996224, 8405384576,
+8413772672, 8422161536, 8430549376, 8438939008, 8447326592,
+8455715456, 8464104832, 8472492928, 8480882048, 8489270656,
+8497659776, 8506045312, 8514434944, 8522823808, 8531208832,
+8539602304, 8547990656, 8556378752, 8564768384, 8573154176,
+8581542784, 8589933952, 8598322816, 8606705024, 8615099264,
+8623487872, 8631876992, 8640264064, 8648653952, 8657040256,
+8665430656, 8673820544, 8682209152, 8690592128, 8698977152,
+8707374464, 8715763328, 8724151424, 8732540032, 8740928384,
+8749315712, 8757704576, 8766089344, 8774480768, 8782871936,
+8791260032, 8799645824, 8808034432, 8816426368, 8824812928,
+8833199488, 8841591424, 8849976448, 8858366336, 8866757248,
+8875147136, 8883532928, 8891923328, 8900306816, 8908700288,
+8917088384, 8925478784, 8933867392, 8942250368, 8950644608,
+8959032704, 8967420544, 8975809664, 8984197504, 8992584064,
+9000976256, 9009362048, 9017752448, 9026141312, 9034530688,
+9042917504, 9051307904, 9059694208, 9068084864, 9076471424,
+9084861824, 9093250688, 9101638528, 9110027648, 9118416512,
+9126803584, 9135188096, 9143581312, 9151969664, 9160356224,
+9168747136, 9177134464, 9185525632, 9193910144, 9202302848,
+9210690688, 9219079552, 9227465344, 9235854464, 9244244864,
+9252633472, 9261021824, 9269411456, 9277799296, 9286188928,
+9294574208, 9302965888, 9311351936, 9319740032, 9328131968,
+9336516736, 9344907392, 9353296768, 9361685888, 9370074752,
+9378463616, 9386849408, 9395239808, 9403629184, 9412016512,
+9420405376, 9428795008, 9437181568, 9445570688, 9453960832,
+9462346624, 9470738048, 9479121536, 9487515008, 9495903616,
+9504289664, 9512678528, 9521067904, 9529456256, 9537843584,
+9546233728, 9554621312, 9563011456, 9571398784, 9579788672,
+9588178304, 9596567168, 9604954496, 9613343104, 9621732992,
+9630121856, 9638508416, 9646898816, 9655283584, 9663675776,
+9672061312, 9680449664, 9688840064, 9697230464, 9705617536,
+9714003584, 9722393984, 9730772608, 9739172224, 9747561088,
+9755945344, 9764338816, 9772726144, 9781116544, 9789503872,
+9797892992, 9806282624, 9814670464, 9823056512, 9831439232,
+9839833984, 9848224384, 9856613504, 9865000576, 9873391232,
+9881772416, 9890162816, 9898556288, 9906940544, 9915333248,
+9923721088, 9932108672, 9940496512, 9948888448, 9957276544,
+9965666176, 9974048384, 9982441088, 9990830464, 9999219584,
+10007602816, 10015996544, 10024385152, 10032774016, 10041163648,
+10049548928, 10057940096, 10066329472, 10074717824, 10083105152,
+10091495296, 10099878784, 10108272256, 10116660608, 10125049216,
+10133437312, 10141825664, 10150213504, 10158601088, 10166991232,
+10175378816, 10183766144, 10192157312, 10200545408, 10208935552,
+10217322112, 10225712768, 10234099328, 10242489472, 10250876032,
+10259264896, 10267656064, 10276042624, 10284429184, 10292820352,
+10301209472, 10309598848, 10317987712, 10326375296, 10334763392,
+10343153536, 10351541632, 10359930752, 10368318592, 10376707456,
+10385096576, 10393484672, 10401867136, 10410262144, 10418647424,
+10427039104, 10435425664, 10443810176, 10452203648, 10460589952,
+10468982144, 10477369472, 10485759104, 10494147712, 10502533504,
+10510923392, 10519313536, 10527702656, 10536091264, 10544478592,
+10552867712, 10561255808, 10569642368, 10578032768, 10586423168,
+10594805632, 10603200128, 10611588992, 10619976064, 10628361344,
+10636754048, 10645143424, 10653531776, 10661920384, 10670307968,
+10678696832, 10687086464, 10695475072, 10703863168, 10712246144,
+10720639616, 10729026688, 10737414784, 10745806208, 10754190976,
+10762581376, 10770971264, 10779356288, 10787747456, 10796135552,
+10804525184, 10812915584, 10821301888, 10829692288, 10838078336,
+10846469248, 10854858368, 10863247232, 10871631488, 10880023424,
+10888412032, 10896799616, 10905188992, 10913574016, 10921964672,
+10930352768, 10938742912, 10947132544, 10955518592, 10963909504,
+10972298368, 10980687488, 10989074816, 10997462912, 11005851776,
+11014241152, 11022627712, 11031017344, 11039403904, 11047793024,
+11056184704, 11064570752, 11072960896, 11081343872, 11089737856,
+11098128256, 11106514816, 11114904448, 11123293568, 11131680128,
+11140065152, 11148458368, 11156845696, 11165236864, 11173624192,
+11182013824, 11190402688, 11198790784, 11207179136, 11215568768,
+11223957376, 11232345728, 11240734592, 11249122688, 11257511296,
+11265899648, 11274285952, 11282675584, 11291065472, 11299452544,
+11307842432, 11316231296, 11324616832, 11333009024, 11341395584,
+11349782656, 11358172288, 11366560384, 11374950016, 11383339648,
+11391721856, 11400117376, 11408504192, 11416893568, 11425283456,
+11433671552, 11442061184, 11450444672, 11458837888, 11467226752,
+11475611776, 11484003968, 11492392064, 11500780672, 11509169024,
+11517550976, 11525944448, 11534335616, 11542724224, 11551111808,
+11559500672, 11567890304, 11576277376, 11584667008, 11593056128,
+11601443456, 11609830016, 11618221952, 11626607488, 11634995072,
+11643387776, 11651775104, 11660161664, 11668552576, 11676940928,
+11685330304, 11693718656, 11702106496, 11710496128, 11718882688,
+11727273088, 11735660416, 11744050048, 11752437376, 11760824704,
+11769216128, 11777604736, 11785991296, 11794381952, 11802770048,
+11811157888, 11819548544, 11827932544, 11836324736, 11844713344,
+11853100928, 11861486464, 11869879936, 11878268032, 11886656896,
+11895044992, 11903433088, 11911822976, 11920210816, 11928600448,
+11936987264, 11945375872, 11953761152, 11962151296, 11970543488,
+11978928512, 11987320448, 11995708288, 12004095104, 12012486272,
+12020875136, 12029255552, 12037652096, 12046039168, 12054429568,
+12062813824, 12071206528, 12079594624, 12087983744, 12096371072,
+12104759936, 12113147264, 12121534592, 12129924992, 12138314624,
+12146703232, 12155091584, 12163481216, 12171864704, 12180255872,
+12188643968, 12197034112, 12205424512, 12213811328, 12222199424,
+12230590336, 12238977664, 12247365248, 12255755392, 12264143488,
+12272531584, 12280920448, 12289309568, 12297694592, 12306086528,
+12314475392, 12322865024, 12331253632, 12339640448, 12348029312,
+12356418944, 12364805248, 12373196672, 12381580928, 12389969024,
+12398357632, 12406750592, 12415138432, 12423527552, 12431916416,
+12440304512, 12448692352, 12457081216, 12465467776, 12473859968,
+12482245504, 12490636672, 12499025536, 12507411584, 12515801728,
+12524190592, 12532577152, 12540966272, 12549354368, 12557743232,
+12566129536, 12574523264, 12582911872, 12591299456, 12599688064,
+12608074624, 12616463488, 12624845696, 12633239936, 12641631616,
+12650019968, 12658407296, 12666795136, 12675183232, 12683574656,
+12691960192, 12700350592, 12708740224, 12717128576, 12725515904,
+12733906816, 12742295168, 12750680192, 12759071872, 12767460736,
+12775848832, 12784236928, 12792626816, 12801014656, 12809404288,
+12817789312, 12826181504, 12834568832, 12842954624, 12851345792,
+12859732352, 12868122496, 12876512128, 12884901248, 12893289088,
+12901672832, 12910067584, 12918455168, 12926842496, 12935232896,
+12943620736, 12952009856, 12960396928, 12968786816, 12977176192,
+12985563776, 12993951104, 13002341504, 13010730368, 13019115392,
+13027506304, 13035895168, 13044272512, 13052673152, 13061062528,
+13069446272, 13077838976, 13086227072, 13094613632, 13103000192,
+13111393664, 13119782528, 13128157568, 13136559232, 13144945024,
+13153329536, 13161724288, 13170111872, 13178502784, 13186884736,
+13195279744, 13203667072, 13212057472, 13220445824, 13228832128,
+13237221248, 13245610624, 13254000512, 13262388352, 13270777472,
+13279166336, 13287553408, 13295943296, 13304331904, 13312719488,
+13321108096, 13329494656, 13337885824, 13346274944, 13354663808,
+13363051136, 13371439232, 13379825024, 13388210816, 13396605056,
+13404995456, 13413380224, 13421771392, 13430159744, 13438546048,
+13446937216, 13455326848, 13463708288, 13472103808, 13480492672,
+13488875648, 13497269888, 13505657728, 13514045312, 13522435712,
+13530824576, 13539210112, 13547599232, 13555989376, 13564379008,
+13572766336, 13581154432, 13589544832, 13597932928, 13606320512,
+13614710656, 13623097472, 13631477632, 13639874944, 13648264064,
+13656652928, 13665041792, 13673430656, 13681818496, 13690207616,
+13698595712, 13706982272, 13715373184, 13723762048, 13732150144,
+13740536704, 13748926592, 13757316224, 13765700992, 13774090112,
+13782477952, 13790869376, 13799259008, 13807647872, 13816036736,
+13824425344, 13832814208, 13841202304, 13849591424, 13857978752,
+13866368896, 13874754688, 13883145344, 13891533184, 13899919232,
+13908311168, 13916692096, 13925085056, 13933473152, 13941866368,
+13950253696, 13958643584, 13967032192, 13975417216, 13983807616,
+13992197504, 14000582272, 14008973696, 14017363072, 14025752192,
+14034137984, 14042528384, 14050918016, 14059301504, 14067691648,
+14076083584, 14084470144, 14092852352, 14101249664, 14109635968,
+14118024832, 14126407552, 14134804352, 14143188608, 14151577984,
+14159968384, 14168357248, 14176741504, 14185127296, 14193521024,
+14201911424, 14210301824, 14218685056, 14227067264, 14235467392,
+14243855488, 14252243072, 14260630144, 14269021568, 14277409408,
+14285799296, 14294187904, 14302571392, 14310961792, 14319353728,
+14327738752, 14336130944, 14344518784, 14352906368, 14361296512,
+14369685376, 14378071424, 14386462592, 14394848128, 14403230848,
+14411627392, 14420013952, 14428402304, 14436793472, 14445181568,
+14453569664, 14461959808, 14470347904, 14478737024, 14487122816,
+14495511424, 14503901824, 14512291712, 14520677504, 14529064832,
+14537456768, 14545845632, 14554234496, 14562618496, 14571011456,
+14579398784, 14587789184, 14596172672, 14604564608, 14612953984,
+14621341312, 14629724288, 14638120832, 14646503296, 14654897536,
+14663284864, 14671675264, 14680061056, 14688447616, 14696835968,
+14705228416, 14713616768, 14722003328, 14730392192, 14738784128,
+14747172736, 14755561088, 14763947648, 14772336512, 14780725376,
+14789110144, 14797499776, 14805892736, 14814276992, 14822670208,
+14831056256, 14839444352, 14847836032, 14856222848, 14864612992,
+14872997504, 14881388672, 14889775744, 14898165376, 14906553472,
+14914944896, 14923329664, 14931721856, 14940109696, 14948497024,
+14956887424, 14965276544, 14973663616, 14982053248, 14990439808,
+14998830976, 15007216768, 15015605888, 15023995264, 15032385152,
+15040768384, 15049154944, 15057549184, 15065939072, 15074328448,
+15082715008, 15091104128, 15099493504, 15107879296, 15116269184,
+15124659584, 15133042304, 15141431936, 15149824384, 15158214272,
+15166602368, 15174991232, 15183378304, 15191760512, 15200154496,
+15208542592, 15216931712, 15225323392, 15233708416, 15242098048,
+15250489216, 15258875264, 15267265408, 15275654528, 15284043136,
+15292431488, 15300819584, 15309208192, 15317596544, 15325986176,
+15334374784, 15342763648, 15351151744, 15359540608, 15367929728,
+15376318336, 15384706432, 15393092992, 15401481856, 15409869952,
+15418258816, 15426649984, 15435037568, 15443425664, 15451815296,
+15460203392, 15468589184, 15476979328, 15485369216, 15493755776,
+15502146944, 15510534272, 15518924416, 15527311232, 15535699072,
+15544089472, 15552478336, 15560866688, 15569254528, 15577642624,
+15586031488, 15594419072, 15602809472, 15611199104, 15619586432,
+15627975296, 15636364928, 15644753792, 15653141888, 15661529216,
+15669918848, 15678305152, 15686696576, 15695083136, 15703474048,
+15711861632, 15720251264, 15728636288, 15737027456, 15745417088,
+15753804928, 15762194048, 15770582656, 15778971008, 15787358336,
+15795747712, 15804132224, 15812523392, 15820909696, 15829300096,
+15837691264, 15846071936, 15854466944, 15862855808, 15871244672,
+15879634816, 15888020608, 15896409728, 15904799104, 15913185152,
+15921577088, 15929966464, 15938354816, 15946743424, 15955129472,
+15963519872, 15971907968, 15980296064, 15988684928, 15997073024,
+16005460864, 16013851264, 16022241152, 16030629248, 16039012736,
+16047406976, 16055794816, 16064181376, 16072571264, 16080957824,
+16089346688, 16097737856, 16106125184, 16114514816, 16122904192,
+16131292544, 16139678848, 16148066944, 16156453504, 16164839552,
+16173236096, 16181623424, 16190012032, 16198401152, 16206790528,
+16215177344, 16223567744, 16231956352, 16240344704, 16248731008,
+16257117824, 16265504384, 16273898624, 16282281856, 16290668672,
+16299064192, 16307449216, 16315842176, 16324230016, 16332613504,
+16341006464, 16349394304, 16357783168, 16366172288, 16374561664,
+16382951296, 16391337856, 16399726208, 16408116352, 16416505472,
+16424892032, 16433282176, 16441668224, 16450058624, 16458448768,
+16466836864, 16475224448, 16483613056, 16492001408, 16500391808,
+16508779648, 16517166976, 16525555328, 16533944192, 16542330752,
+16550719616, 16559110528, 16567497088, 16575888512, 16584274816,
+16592665472, 16601051008, 16609442944, 16617832064, 16626218624,
+16634607488, 16642996096, 16651385728, 16659773824, 16668163712,
+16676552576, 16684938112, 16693328768, 16701718144, 16710095488,
+16718492288, 16726883968, 16735272832, 16743661184, 16752049792,
+16760436608, 16768827008, 16777214336, 16785599104, 16793992832,
+16802381696, 16810768768, 16819151744, 16827542656, 16835934848,
+16844323712, 16852711552, 16861101952, 16869489536, 16877876864,
+16886265728, 16894653056, 16903044736, 16911431296, 16919821696,
+16928207488, 16936592768, 16944987776, 16953375616, 16961763968,
+16970152832, 16978540928, 16986929536, 16995319168, 17003704448,
+17012096896, 17020481152, 17028870784, 17037262208, 17045649536,
+17054039936, 17062426496, 17070814336, 17079205504, 17087592064,
+17095978112, 17104369024, 17112759424, 17121147776, 17129536384,
+17137926016, 17146314368, 17154700928, 17163089792, 17171480192,
+17179864192, 17188256896, 17196644992, 17205033856, 17213423488,
+17221811072, 17230198912, 17238588032, 17246976896, 17255360384,
+17263754624, 17272143232, 17280530048, 17288918912, 17297309312,
+17305696384, 17314085504, 17322475136, 17330863744, 17339252096,
+17347640192, 17356026496, 17364413824, 17372796544, 17381190016,
+17389583488, 17397972608, 17406360704, 17414748544, 17423135872,
+17431527296, 17439915904, 17448303232, 17456691584, 17465081728,
+17473468288, 17481857408, 17490247552, 17498635904, 17507022464,
+17515409024, 17523801728, 17532189824, 17540577664, 17548966016,
+17557353344, 17565741184, 17574131584, 17582519168, 17590907008,
+17599296128, 17607687808, 17616076672, 17624455808, 17632852352,
+17641238656, 17649630848, 17658018944, 17666403968, 17674794112,
+17683178368, 17691573376, 17699962496, 17708350592, 17716739968,
+17725126528, 17733517184, 17741898112, 17750293888, 17758673024,
+17767070336, 17775458432, 17783848832, 17792236928, 17800625536,
+17809012352, 17817402752, 17825785984, 17834178944, 17842563968,
+17850955648, 17859344512, 17867732864, 17876119424, 17884511872,
+17892900224, 17901287296, 17909677696, 17918058112, 17926451072,
+17934843776, 17943230848, 17951609216, 17960008576, 17968397696,
+17976784256, 17985175424, 17993564032, 18001952128, 18010339712,
+18018728576, 18027116672, 18035503232, 18043894144, 18052283264,
+18060672128, 18069056384, 18077449856, 18085837184, 18094225792,
+18102613376, 18111004544, 18119388544, 18127781248, 18136170368,
+18144558976, 18152947328, 18161336192, 18169724288, 18178108544,
+18186498944, 18194886784, 18203275648, 18211666048, 18220048768,
+18228444544, 18236833408, 18245220736]
+
+cache_sizes = [
+16776896, 16907456, 17039296, 17170112, 17301056, 17432512, 17563072,
+17693888, 17824192, 17955904, 18087488, 18218176, 18349504, 18481088,
+18611392, 18742336, 18874304, 19004224, 19135936, 19267264, 19398208,
+19529408, 19660096, 19791424, 19922752, 20053952, 20184896, 20315968,
+20446912, 20576576, 20709184, 20840384, 20971072, 21102272, 21233216,
+21364544, 21494848, 21626816, 21757376, 21887552, 22019392, 22151104,
+22281536, 22412224, 22543936, 22675264, 22806464, 22935872, 23068096,
+23198272, 23330752, 23459008, 23592512, 23723968, 23854912, 23986112,
+24116672, 24247616, 24378688, 24509504, 24640832, 24772544, 24903488,
+25034432, 25165376, 25296704, 25427392, 25558592, 25690048, 25820096,
+25951936, 26081728, 26214208, 26345024, 26476096, 26606656, 26737472,
+26869184, 26998208, 27131584, 27262528, 27393728, 27523904, 27655744,
+27786688, 27917888, 28049344, 28179904, 28311488, 28441792, 28573504,
+28700864, 28835648, 28966208, 29096768, 29228608, 29359808, 29490752,
+29621824, 29752256, 29882816, 30014912, 30144448, 30273728, 30406976,
+30538432, 30670784, 30799936, 30932672, 31063744, 31195072, 31325248,
+31456192, 31588288, 31719232, 31850432, 31981504, 32110784, 32243392,
+32372672, 32505664, 32636608, 32767808, 32897344, 33029824, 33160768,
+33289664, 33423296, 33554368, 33683648, 33816512, 33947456, 34076992,
+34208704, 34340032, 34471744, 34600256, 34734016, 34864576, 34993984,
+35127104, 35258176, 35386688, 35518528, 35650624, 35782336, 35910976,
+36044608, 36175808, 36305728, 36436672, 36568384, 36699968, 36830656,
+36961984, 37093312, 37223488, 37355072, 37486528, 37617472, 37747904,
+37879232, 38009792, 38141888, 38272448, 38403392, 38535104, 38660672,
+38795584, 38925632, 39059264, 39190336, 39320768, 39452096, 39581632,
+39713984, 39844928, 39974848, 40107968, 40238144, 40367168, 40500032,
+40631744, 40762816, 40894144, 41023552, 41155904, 41286208, 41418304,
+41547712, 41680448, 41811904, 41942848, 42073792, 42204992, 42334912,
+42467008, 42597824, 42729152, 42860096, 42991552, 43122368, 43253696,
+43382848, 43515712, 43646912, 43777088, 43907648, 44039104, 44170432,
+44302144, 44433344, 44564288, 44694976, 44825152, 44956864, 45088448,
+45219008, 45350464, 45481024, 45612608, 45744064, 45874496, 46006208,
+46136768, 46267712, 46399424, 46529344, 46660672, 46791488, 46923328,
+47053504, 47185856, 47316928, 47447872, 47579072, 47710144, 47839936,
+47971648, 48103232, 48234176, 48365248, 48496192, 48627136, 48757312,
+48889664, 49020736, 49149248, 49283008, 49413824, 49545152, 49675712,
+49807168, 49938368, 50069056, 50200256, 50331584, 50462656, 50593472,
+50724032, 50853952, 50986048, 51117632, 51248576, 51379904, 51510848,
+51641792, 51773248, 51903296, 52035136, 52164032, 52297664, 52427968,
+52557376, 52690112, 52821952, 52952896, 53081536, 53213504, 53344576,
+53475776, 53608384, 53738816, 53870528, 54000832, 54131776, 54263744,
+54394688, 54525248, 54655936, 54787904, 54918592, 55049152, 55181248,
+55312064, 55442752, 55574336, 55705024, 55836224, 55967168, 56097856,
+56228672, 56358592, 56490176, 56621888, 56753728, 56884928, 57015488,
+57146816, 57278272, 57409216, 57540416, 57671104, 57802432, 57933632,
+58064576, 58195264, 58326976, 58457408, 58588864, 58720192, 58849984,
+58981696, 59113024, 59243456, 59375552, 59506624, 59637568, 59768512,
+59897792, 60030016, 60161984, 60293056, 60423872, 60554432, 60683968,
+60817216, 60948032, 61079488, 61209664, 61341376, 61471936, 61602752,
+61733696, 61865792, 61996736, 62127808, 62259136, 62389568, 62520512,
+62651584, 62781632, 62910784, 63045056, 63176128, 63307072, 63438656,
+63569216, 63700928, 63831616, 63960896, 64093888, 64225088, 64355392,
+64486976, 64617664, 64748608, 64879424, 65009216, 65142464, 65273792,
+65402816, 65535424, 65666752, 65797696, 65927744, 66060224, 66191296,
+66321344, 66453056, 66584384, 66715328, 66846656, 66977728, 67108672,
+67239104, 67370432, 67501888, 67631296, 67763776, 67895104, 68026304,
+68157248, 68287936, 68419264, 68548288, 68681408, 68811968, 68942912,
+69074624, 69205568, 69337024, 69467584, 69599168, 69729472, 69861184,
+69989824, 70122944, 70253888, 70385344, 70515904, 70647232, 70778816,
+70907968, 71040832, 71171648, 71303104, 71432512, 71564992, 71695168,
+71826368, 71958464, 72089536, 72219712, 72350144, 72482624, 72613568,
+72744512, 72875584, 73006144, 73138112, 73268672, 73400128, 73530944,
+73662272, 73793344, 73924544, 74055104, 74185792, 74316992, 74448832,
+74579392, 74710976, 74841664, 74972864, 75102784, 75233344, 75364544,
+75497024, 75627584, 75759296, 75890624, 76021696, 76152256, 76283072,
+76414144, 76545856, 76676672, 76806976, 76937792, 77070016, 77200832,
+77331392, 77462464, 77593664, 77725376, 77856448, 77987776, 78118336,
+78249664, 78380992, 78511424, 78642496, 78773056, 78905152, 79033664,
+79166656, 79297472, 79429568, 79560512, 79690816, 79822784, 79953472,
+80084672, 80214208, 80346944, 80477632, 80608576, 80740288, 80870848,
+81002048, 81133504, 81264448, 81395648, 81525952, 81657536, 81786304,
+81919808, 82050112, 82181312, 82311616, 82443968, 82573376, 82705984,
+82835776, 82967744, 83096768, 83230528, 83359552, 83491264, 83622464,
+83753536, 83886016, 84015296, 84147776, 84277184, 84409792, 84540608,
+84672064, 84803008, 84934336, 85065152, 85193792, 85326784, 85458496,
+85589312, 85721024, 85851968, 85982656, 86112448, 86244416, 86370112,
+86506688, 86637632, 86769344, 86900672, 87031744, 87162304, 87293632,
+87424576, 87555392, 87687104, 87816896, 87947968, 88079168, 88211264,
+88341824, 88473152, 88603712, 88735424, 88862912, 88996672, 89128384,
+89259712, 89390272, 89521984, 89652544, 89783872, 89914816, 90045376,
+90177088, 90307904, 90438848, 90569152, 90700096, 90832832, 90963776,
+91093696, 91223744, 91356992, 91486784, 91618496, 91749824, 91880384,
+92012224, 92143552, 92273344, 92405696, 92536768, 92666432, 92798912,
+92926016, 93060544, 93192128, 93322816, 93453632, 93583936, 93715136,
+93845056, 93977792, 94109504, 94240448, 94371776, 94501184, 94632896,
+94764224, 94895552, 95023424, 95158208, 95287744, 95420224, 95550016,
+95681216, 95811904, 95943872, 96075328, 96203584, 96337856, 96468544,
+96599744, 96731072, 96860992, 96992576, 97124288, 97254848, 97385536,
+97517248, 97647808, 97779392, 97910464, 98041408, 98172608, 98303168,
+98434496, 98565568, 98696768, 98827328, 98958784, 99089728, 99220928,
+99352384, 99482816, 99614272, 99745472, 99876416, 100007104,
+100138048, 100267072, 100401088, 100529984, 100662592, 100791872,
+100925248, 101056064, 101187392, 101317952, 101449408, 101580608,
+101711296, 101841728, 101973824, 102104896, 102235712, 102366016,
+102498112, 102628672, 102760384, 102890432, 103021888, 103153472,
+103284032, 103415744, 103545152, 103677248, 103808576, 103939648,
+104070976, 104201792, 104332736, 104462528, 104594752, 104725952,
+104854592, 104988608, 105118912, 105247808, 105381184, 105511232,
+105643072, 105774784, 105903296, 106037056, 106167872, 106298944,
+106429504, 106561472, 106691392, 106822592, 106954304, 107085376,
+107216576, 107346368, 107478464, 107609792, 107739712, 107872192,
+108003136, 108131392, 108265408, 108396224, 108527168, 108657344,
+108789568, 108920384, 109049792, 109182272, 109312576, 109444928,
+109572928, 109706944, 109837888, 109969088, 110099648, 110230976,
+110362432, 110492992, 110624704, 110755264, 110886208, 111017408,
+111148864, 111279296, 111410752, 111541952, 111673024, 111803456,
+111933632, 112066496, 112196416, 112328512, 112457792, 112590784,
+112715968, 112852672, 112983616, 113114944, 113244224, 113376448,
+113505472, 113639104, 113770304, 113901376, 114031552, 114163264,
+114294592, 114425536, 114556864, 114687424, 114818624, 114948544,
+115080512, 115212224, 115343296, 115473472, 115605184, 115736128,
+115867072, 115997248, 116128576, 116260288, 116391488, 116522944,
+116652992, 116784704, 116915648, 117046208, 117178304, 117308608,
+117440192, 117569728, 117701824, 117833024, 117964096, 118094656,
+118225984, 118357312, 118489024, 118617536, 118749632, 118882112,
+119012416, 119144384, 119275328, 119406016, 119537344, 119668672,
+119798464, 119928896, 120061376, 120192832, 120321728, 120454336,
+120584512, 120716608, 120848192, 120979136, 121109056, 121241408,
+121372352, 121502912, 121634752, 121764416, 121895744, 122027072,
+122157632, 122289088, 122421184, 122550592, 122682944, 122813888,
+122945344, 123075776, 123207488, 123338048, 123468736, 123600704,
+123731264, 123861952, 123993664, 124124608, 124256192, 124386368,
+124518208, 124649024, 124778048, 124911296, 125041088, 125173696,
+125303744, 125432896, 125566912, 125696576, 125829056, 125958592,
+126090304, 126221248, 126352832, 126483776, 126615232, 126746432,
+126876608, 127008704, 127139392, 127270336, 127401152, 127532224,
+127663552, 127794752, 127925696, 128055232, 128188096, 128319424,
+128449856, 128581312, 128712256, 128843584, 128973632, 129103808,
+129236288, 129365696, 129498944, 129629888, 129760832, 129892288,
+130023104, 130154048, 130283968, 130416448, 130547008, 130678336,
+130807616, 130939456, 131071552, 131202112, 131331776, 131464384,
+131594048, 131727296, 131858368, 131987392, 132120256, 132250816,
+132382528, 132513728, 132644672, 132774976, 132905792, 133038016,
+133168832, 133299392, 133429312, 133562048, 133692992, 133823296,
+133954624, 134086336, 134217152, 134348608, 134479808, 134607296,
+134741056, 134872384, 135002944, 135134144, 135265472, 135396544,
+135527872, 135659072, 135787712, 135921472, 136052416, 136182848,
+136313792, 136444864, 136576448, 136707904, 136837952, 136970048,
+137099584, 137232064, 137363392, 137494208, 137625536, 137755712,
+137887424, 138018368, 138149824, 138280256, 138411584, 138539584,
+138672832, 138804928, 138936128, 139066688, 139196864, 139328704,
+139460032, 139590208, 139721024, 139852864, 139984576, 140115776,
+140245696, 140376512, 140508352, 140640064, 140769856, 140902336,
+141032768, 141162688, 141294016, 141426496, 141556544, 141687488,
+141819584, 141949888, 142080448, 142212544, 142342336, 142474432,
+142606144, 142736192, 142868288, 142997824, 143129408, 143258944,
+143392448, 143523136, 143653696, 143785024, 143916992, 144045632,
+144177856, 144309184, 144440768, 144570688, 144701888, 144832448,
+144965056, 145096384, 145227584, 145358656, 145489856, 145620928,
+145751488, 145883072, 146011456, 146144704, 146275264, 146407232,
+146538176, 146668736, 146800448, 146931392, 147062336, 147193664,
+147324224, 147455936, 147586624, 147717056, 147848768, 147979456,
+148110784, 148242368, 148373312, 148503232, 148635584, 148766144,
+148897088, 149028416, 149159488, 149290688, 149420224, 149551552,
+149683136, 149814976, 149943616, 150076352, 150208064, 150338624,
+150470464, 150600256, 150732224, 150862784, 150993088, 151125952,
+151254976, 151388096, 151519168, 151649728, 151778752, 151911104,
+152042944, 152174144, 152304704, 152435648, 152567488, 152698816,
+152828992, 152960576, 153091648, 153222976, 153353792, 153484096,
+153616192, 153747008, 153878336, 154008256, 154139968, 154270912,
+154402624, 154533824, 154663616, 154795712, 154926272, 155057984,
+155188928, 155319872, 155450816, 155580608, 155712064, 155843392,
+155971136, 156106688, 156237376, 156367424, 156499264, 156630976,
+156761536, 156892352, 157024064, 157155008, 157284416, 157415872,
+157545536, 157677248, 157810496, 157938112, 158071744, 158203328,
+158334656, 158464832, 158596288, 158727616, 158858048, 158988992,
+159121216, 159252416, 159381568, 159513152, 159645632, 159776192,
+159906496, 160038464, 160169536, 160300352, 160430656, 160563008,
+160693952, 160822208, 160956352, 161086784, 161217344, 161349184,
+161480512, 161611456, 161742272, 161873216, 162002752, 162135872,
+162266432, 162397888, 162529216, 162660032, 162790976, 162922048,
+163052096, 163184576, 163314752, 163446592, 163577408, 163707968,
+163839296, 163969984, 164100928, 164233024, 164364224, 164494912,
+164625856, 164756672, 164887616, 165019072, 165150016, 165280064,
+165412672, 165543104, 165674944, 165805888, 165936832, 166067648,
+166198336, 166330048, 166461248, 166591552, 166722496, 166854208,
+166985408, 167116736, 167246656, 167378368, 167508416, 167641024,
+167771584, 167903168, 168034112, 168164032, 168295744, 168427456,
+168557632, 168688448, 168819136, 168951616, 169082176, 169213504,
+169344832, 169475648, 169605952, 169738048, 169866304, 169999552,
+170131264, 170262464, 170393536, 170524352, 170655424, 170782016,
+170917696, 171048896, 171179072, 171310784, 171439936, 171573184,
+171702976, 171835072, 171966272, 172097216, 172228288, 172359232,
+172489664, 172621376, 172747712, 172883264, 173014208, 173144512,
+173275072, 173407424, 173539136, 173669696, 173800768, 173931712,
+174063424, 174193472, 174325696, 174455744, 174586816, 174718912,
+174849728, 174977728, 175109696, 175242688, 175374272, 175504832,
+175636288, 175765696, 175898432, 176028992, 176159936, 176291264,
+176422592, 176552512, 176684864, 176815424, 176946496, 177076544,
+177209152, 177340096, 177470528, 177600704, 177731648, 177864256,
+177994816, 178126528, 178257472, 178387648, 178518464, 178650176,
+178781888, 178912064, 179044288, 179174848, 179305024, 179436736,
+179568448, 179698496, 179830208, 179960512, 180092608, 180223808,
+180354752, 180485696, 180617152, 180748096, 180877504, 181009984,
+181139264, 181272512, 181402688, 181532608, 181663168, 181795136,
+181926592, 182057536, 182190016, 182320192, 182451904, 182582336,
+182713792, 182843072, 182976064, 183107264, 183237056, 183368384,
+183494848, 183631424, 183762752, 183893824, 184024768, 184154816,
+184286656, 184417984, 184548928, 184680128, 184810816, 184941248,
+185072704, 185203904, 185335616, 185465408, 185596352, 185727296,
+185859904, 185989696, 186121664, 186252992, 186383552, 186514112,
+186645952, 186777152, 186907328, 187037504, 187170112, 187301824,
+187429184, 187562048, 187693504, 187825472, 187957184, 188087104,
+188218304, 188349376, 188481344, 188609728, 188743616, 188874304,
+189005248, 189136448, 189265088, 189396544, 189528128, 189660992,
+189791936, 189923264, 190054208, 190182848, 190315072, 190447424,
+190577984, 190709312, 190840768, 190971328, 191102656, 191233472,
+191364032, 191495872, 191626816, 191758016, 191888192, 192020288,
+192148928, 192282176, 192413504, 192542528, 192674752, 192805952,
+192937792, 193068608, 193198912, 193330496, 193462208, 193592384,
+193723456, 193854272, 193985984, 194116672, 194247232, 194379712,
+194508352, 194641856, 194772544, 194900672, 195035072, 195166016,
+195296704, 195428032, 195558592, 195690304, 195818176, 195952576,
+196083392, 196214336, 196345792, 196476736, 196607552, 196739008,
+196869952, 197000768, 197130688, 197262784, 197394368, 197523904,
+197656384, 197787584, 197916608, 198049472, 198180544, 198310208,
+198442432, 198573632, 198705088, 198834368, 198967232, 199097792,
+199228352, 199360192, 199491392, 199621696, 199751744, 199883968,
+200014016, 200146624, 200276672, 200408128, 200540096, 200671168,
+200801984, 200933312, 201062464, 201194944, 201326144, 201457472,
+201588544, 201719744, 201850816, 201981632, 202111552, 202244032,
+202374464, 202505152, 202636352, 202767808, 202898368, 203030336,
+203159872, 203292608, 203423296, 203553472, 203685824, 203816896,
+203947712, 204078272, 204208192, 204341056, 204472256, 204603328,
+204733888, 204864448, 204996544, 205125568, 205258304, 205388864,
+205517632, 205650112, 205782208, 205913536, 206044736, 206176192,
+206307008, 206434496, 206569024, 206700224, 206831168, 206961856,
+207093056, 207223616, 207355328, 207486784, 207616832, 207749056,
+207879104, 208010048, 208141888, 208273216, 208404032, 208534336,
+208666048, 208796864, 208927424, 209059264, 209189824, 209321792,
+209451584, 209582656, 209715136, 209845568, 209976896, 210106432,
+210239296, 210370112, 210501568, 210630976, 210763712, 210894272,
+211024832, 211156672, 211287616, 211418176, 211549376, 211679296,
+211812032, 211942592, 212074432, 212204864, 212334016, 212467648,
+212597824, 212727616, 212860352, 212991424, 213120832, 213253952,
+213385024, 213515584, 213645632, 213777728, 213909184, 214040128,
+214170688, 214302656, 214433728, 214564544, 214695232, 214826048,
+214956992, 215089088, 215219776, 215350592, 215482304, 215613248,
+215743552, 215874752, 216005312, 216137024, 216267328, 216399296,
+216530752, 216661696, 216790592, 216923968, 217054528, 217183168,
+217316672, 217448128, 217579072, 217709504, 217838912, 217972672,
+218102848, 218233024, 218364736, 218496832, 218627776, 218759104,
+218888896, 219021248, 219151936, 219281728, 219413056, 219545024,
+219675968, 219807296, 219938624, 220069312, 220200128, 220331456,
+220461632, 220592704, 220725184, 220855744, 220987072, 221117888,
+221249216, 221378368, 221510336, 221642048, 221772736, 221904832,
+222031808, 222166976, 222297536, 222428992, 222559936, 222690368,
+222820672, 222953152, 223083968, 223213376, 223345984, 223476928,
+223608512, 223738688, 223869376, 224001472, 224132672, 224262848,
+224394944, 224524864, 224657344, 224788288, 224919488, 225050432,
+225181504, 225312704, 225443776, 225574592, 225704768, 225834176,
+225966784, 226097216, 226229824, 226360384, 226491712, 226623424,
+226754368, 226885312, 227015104, 227147456, 227278528, 227409472,
+227539904, 227669696, 227802944, 227932352, 228065216, 228196288,
+228326464, 228457792, 228588736, 228720064, 228850112, 228981056,
+229113152, 229243328, 229375936, 229505344, 229636928, 229769152,
+229894976, 230030272, 230162368, 230292416, 230424512, 230553152,
+230684864, 230816704, 230948416, 231079616, 231210944, 231342016,
+231472448, 231603776, 231733952, 231866176, 231996736, 232127296,
+232259392, 232388672, 232521664, 232652608, 232782272, 232914496,
+233043904, 233175616, 233306816, 233438528, 233569984, 233699776,
+233830592, 233962688, 234092224, 234221888, 234353984, 234485312,
+234618304, 234749888, 234880832, 235011776, 235142464, 235274048,
+235403456, 235535936, 235667392, 235797568, 235928768, 236057152,
+236190272, 236322752, 236453312, 236583616, 236715712, 236846528,
+236976448, 237108544, 237239104, 237371072, 237501632, 237630784,
+237764416, 237895232, 238026688, 238157632, 238286912, 238419392,
+238548032, 238681024, 238812608, 238941632, 239075008, 239206336,
+239335232, 239466944, 239599168, 239730496, 239861312, 239992384,
+240122816, 240254656, 240385856, 240516928, 240647872, 240779072,
+240909632, 241040704, 241171904, 241302848, 241433408, 241565248,
+241696192, 241825984, 241958848, 242088256, 242220224, 242352064,
+242481856, 242611648, 242744896, 242876224, 243005632, 243138496,
+243268672, 243400384, 243531712, 243662656, 243793856, 243924544,
+244054592, 244187072, 244316608, 244448704, 244580032, 244710976,
+244841536, 244972864, 245104448, 245233984, 245365312, 245497792,
+245628736, 245759936, 245889856, 246021056, 246152512, 246284224,
+246415168, 246545344, 246675904, 246808384, 246939584, 247070144,
+247199552, 247331648, 247463872, 247593536, 247726016, 247857088,
+247987648, 248116928, 248249536, 248380736, 248512064, 248643008,
+248773312, 248901056, 249036608, 249167552, 249298624, 249429184,
+249560512, 249692096, 249822784, 249954112, 250085312, 250215488,
+250345792, 250478528, 250608704, 250739264, 250870976, 251002816,
+251133632, 251263552, 251395136, 251523904, 251657792, 251789248,
+251919424, 252051392, 252182464, 252313408, 252444224, 252575552,
+252706624, 252836032, 252968512, 253099712, 253227584, 253361728,
+253493056, 253623488, 253754432, 253885504, 254017216, 254148032,
+254279488, 254410432, 254541376, 254672576, 254803264, 254933824,
+255065792, 255196736, 255326528, 255458752, 255589952, 255721408,
+255851072, 255983296, 256114624, 256244416, 256374208, 256507712,
+256636096, 256768832, 256900544, 257031616, 257162176, 257294272,
+257424448, 257555776, 257686976, 257818432, 257949632, 258079552,
+258211136, 258342464, 258473408, 258603712, 258734656, 258867008,
+258996544, 259127744, 259260224, 259391296, 259522112, 259651904,
+259784384, 259915328, 260045888, 260175424, 260308544, 260438336,
+260570944, 260700992, 260832448, 260963776, 261092672, 261226304,
+261356864, 261487936, 261619648, 261750592, 261879872, 262011968,
+262143424, 262274752, 262404416, 262537024, 262667968, 262799296,
+262928704, 263061184, 263191744, 263322944, 263454656, 263585216,
+263716672, 263847872, 263978944, 264108608, 264241088, 264371648,
+264501184, 264632768, 264764096, 264895936, 265024576, 265158464,
+265287488, 265418432, 265550528, 265681216, 265813312, 265943488,
+266075968, 266206144, 266337728, 266468032, 266600384, 266731072,
+266862272, 266993344, 267124288, 267255616, 267386432, 267516992,
+267648704, 267777728, 267910592, 268040512, 268172096, 268302784,
+268435264, 268566208, 268696256, 268828096, 268959296, 269090368,
+269221312, 269352256, 269482688, 269614784, 269745856, 269876416,
+270007616, 270139328, 270270272, 270401216, 270531904, 270663616,
+270791744, 270924736, 271056832, 271186112, 271317184, 271449536,
+271580992, 271711936, 271843136, 271973056, 272105408, 272236352,
+272367296, 272498368, 272629568, 272759488, 272891456, 273022784,
+273153856, 273284672, 273415616, 273547072, 273677632, 273808448,
+273937088, 274071488, 274200896, 274332992, 274463296, 274595392,
+274726208, 274857536, 274988992, 275118656, 275250496, 275382208,
+275513024, 275643968, 275775296, 275906368, 276037184, 276167872,
+276297664, 276429376, 276560576, 276692672, 276822976, 276955072,
+277085632, 277216832, 277347008, 277478848, 277609664, 277740992,
+277868608, 278002624, 278134336, 278265536, 278395328, 278526784,
+278657728, 278789824, 278921152, 279052096, 279182912, 279313088,
+279443776, 279576256, 279706048, 279838528, 279969728, 280099648,
+280230976, 280361408, 280493632, 280622528, 280755392, 280887104,
+281018176, 281147968, 281278912, 281411392, 281542592, 281673152,
+281803712, 281935552, 282066496, 282197312, 282329024, 282458816,
+282590272, 282720832, 282853184, 282983744, 283115072, 283246144,
+283377344, 283508416, 283639744, 283770304, 283901504, 284032576,
+284163136, 284294848, 284426176, 284556992, 284687296, 284819264,
+284950208, 285081536]
+```
diff --git a/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
new file mode 100644
index 00000000000..f251fa3ce68
--- /dev/null
+++ b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
@@ -0,0 +1,37 @@
+---
+title: Algorithmes de minage
+description: Un regard détaillé sur les algorithmes utilisés pour le minage Ethereum.
+lang: fr
+---
+
+
+La preuve de travail n'est plus le mécanisme de consensus d'Ethereum, ce qui signifie que le minage a été arrêté. En lieu et place, Ethereum est sécurisé par les validateurs qui misent de l'ETH. Vous pouvez commencer à miser votre ETH dès aujourd'hui. En savoir plus sur La Fusion, la preuve d'enjeu et la mise en jeu. Cette page n'a qu'un intérêt historique.
+
+
+Le minage Ethereum utilisait un algorithme connu sous le nom d'Ethash. L'idée fondamentale de l'algorithme est qu'un mineur tente de trouver une entrée nonce en utilisant le calcul de force brute afin que le hachage en résultant soit plus petit qu'un seuil déterminé par la difficulté calculée. Ce seuil de difficulté peut être ajusté dynamiquement, ce qui permet à la production de blocs de se réaliser à intervalles réguliers.
+
+## Prérequis {#prerequisites}
+
+Pour mieux comprendre cette page, nous vous recommandons de lire d'abord le [consensus de preuve de travail](/developers/docs/consensus-mechanisms/pow) et le [minage](/developers/docs/consensus-mechanisms/pow/mining).
+
+## Dagger Hashimoto {#dagger-hashimoto}
+
+Dagger Hashimoto était un algorithme de recherche précurseur pour le minage Ethereum qu'Ethash a remplacé. Il s'agissait de la fusion de deux algorithmes différents : Dagger et Hashimoto. Il ne s'agissait que d'une implémentation de recherche et a été remplacé par Ethash au moment du lancement du réseau principal Ethereum.
+
+[Dagger](http://www.hashcash.org/papers/dagger.html) implique la génération d'un [Graphe orienté acyclique (DAG en anglais)](https://en.wikipedia.org/wiki/Directed_acyclic_graph), dont des tranches aléatoires sont hachées ensemble. Le principe fondamental est que chaque nonce ne nécessite qu'une petite partie d'un grand arbre de données. Recalculer le sous-arbre pour chaque nonce est prohibitif pour le minage – d’où la nécessité de stocker l’arbre – mais correct pour un unique once de vérification. Dagger a été conçu pour être une alternative aux algorithmes existants comme Scrypt, qui sont difficiles à vérifier lorsque la difficulté de mémoire augmente à des niveaux réellement sécurisés. Cependant, Dagger était vulnérable à une accélération matérielle de la mémoire partagée et a été abandonné en faveur d'autres pistes de recherche.
+
+[Hashimoto](http://diyhpl.us/%7Ebryan/papers2/bitcoin/meh/hashimoto.pdf) est un algorithme qui ajoute une résistance ASIC en étant lié aux E / S (c'est-à-dire que les lectures de mémoire sont le facteur limitant du processus de minage). La théorie est que la RAM est plus disponible que le calcul. Des milliards de dollars de recherche ont déjà investis pour étudier les possibilités d'optimisation de la mémoire vive pour différents cas d’utilisation, ce qui implique souvent des modèles d’accès quasi aléatoires (d’où la « mémoire à accès aléatoire »). En conséquence, la RAM existante est susceptible d'être modérément proche de l'optimisation pour l'évaluation de l'algorithme. Hashimoto utilise la blockchain comme source de données, satisfaisant simultanément (1) et (3) ci-dessus.
+
+Dagger-Hashimoto a utilisé des versions modifiées des algorithmes Dagger et Hashimoto. La différence entre Dagger Hashimoto et Hashimoto réside dans le fait qu'au lieu d'utiliser la blockchain comme une source de données, Dagger Hashimoto utilise un ensemble de données générées sur mesure, qui se met à jour en fonction des données de chaque bloc N. L'ensemble de données est généré à l'aide de l'algorithme Dagger permettant de calculer efficacement un sous-ensemble spécifique à chaque nonce pour l'algorithme de vérification du client léger. La différence entre Dagger Hashimoto et Dagger est que, contrairement à l'original Dagger, le jeu de données utilisé pour interroger le bloc est semi-permanent, mis à jour uniquement à intervalles occasionnels (par exemple une fois par semaine). Cela signifie que la partie de l'effort de génération du jeu de données est proche de zéro. Les arguments de Sergio Lerner concernant les vitesses de mémoires partagées deviennent donc négligeables.
+
+En savoir plus sur [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining-algorithms/dagger-hashimoto).
+
+## Ethash {#ethash}
+
+Ethash était l'algorithme de minage qui était en fait utilisé sur le véritable réseau principal Ethereum sous l'architecture désormais obsolète de la preuve de travail. Ethash a été en fait un nouveau nom donné à une version spécifique de Dagger-Hashimoto après que l'algorithme a été mis à jour de manière significative, tout en héritant des principes fondamentaux de son prédécesseur. Le réseau principal Ethereum a toujours utilisé Ethash - Dagger Hashimoto était une version R&D de l'algorithme de minage qui a été remplacé avant que le minage ne démarre sur le réseau principal Ethereum.
+
+[En savoir plus sur Ethash](/developers/docs/consensus-mechanisms/pow/mining-algorithms/ethash).
+
+## Complément d'information {#further-reading}
+
+_Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
diff --git a/src/content/translations/fr/developers/docs/data-and-analytics/block-explorers/index.md b/src/content/translations/fr/developers/docs/data-and-analytics/block-explorers/index.md
index 95ab2385c51..73c4ac397a4 100644
--- a/src/content/translations/fr/developers/docs/data-and-analytics/block-explorers/index.md
+++ b/src/content/translations/fr/developers/docs/data-and-analytics/block-explorers/index.md
@@ -1,5 +1,5 @@
---
-title: Explorateurs de bloc
+title: Explorateurs de blocs
description: Introduction aux explorateurs de blocs, votre portail vers le monde des données de la blockchain, où vous pouvez rechercher des informations sur les transactions, les comptes, les contrats et bien plus.
lang: fr
sidebarDepth: 3
@@ -13,66 +13,57 @@ Pour que les données fournies par un explorateur de blocs aient du sens, vous d
## Services {#services}
-- [Etherscan](https://etherscan.io/) - _Également disponible en chinois, en coréen, en japonais et en russe_
-- [Etherchain](https://www.etherchain.org/)
-- [Ethplorer](https://ethplorer.io/) - _Également disponible en chinois, en espagnol, en français, en turc, en russe, en coréen et en vietnamien_
-- [Blockchair](https://blockchair.com/ethereum) - _Également disponible en chinois, en espagnol, en farsi, en français, en italien, en néerlandais, en portugais et en russe_-
+- [Etherscan](https://etherscan.io/) - _Également disponible en chinois, coréen, russe et japonais_
+- [Beaconcha.in](https://beaconcha.in/)
+- [Blockchair](https://blockchair.com/ethereum) - _Également disponible en espagnol, français, italien, néerlandais, portugais, russe, chinois et Farsi_
- [Blockscout](https://blockscout.com/)
+- [Etherchain](https://www.etherchain.org/)
+- [Ethplorer](https://ethplorer.io/) - _Aussi disponible en chinois, espagnol, français, turc, russe, coréen et vietnamien_
- [OKLink](https://www.oklink.com/eth)
+- [Otterscan](https://otterscan.io/)
+- [Sirato](https://www.web3labs.com/sirato)
+- [EthVM](https://www.ethvm.com/)
## Données {#data}
-De part sa conception, Ethereum est transparent, tout est donc vérifiable. Les explorateurs de blocs fournissent l'interface pour obtenir les informations, à la fois pour le réseau principal Ethereum (mainnet) et pour les réseaux de test (testnets), si besoin est.
+De part sa conception, Ethereum est transparent, tout est donc vérifiable. Les explorateurs de blocs fournissent l'interface pour obtenir les informations, à la fois pour le réseau principal Ethereum (mainnet) et pour les réseaux de test (testnets), si besoin est. Les données sont divisées en données d'exécution et de consensus. Les données d'exécution se réfèrent aux transactions qui ont été exécutées dans un bloc spécifique. Les données de consensus se réfèrent aux blocs eux-mêmes et aux validateurs qui les ont proposés.
Voici un résumé des types de données que vous pouvez obtenir d'un explorateur de blocs.
-### Blocs {#blocks}
+### Données d'exécution {#execution-data}
-De nouveaux blocs sont ajoutés à Ethereum environ toutes les 12 secondes (cela peut fluctuer). Un flux de données presque constant est donc ajouté aux explorateurs de blocs. Les blocs contiennent de nombreuses données importantes qui peuvent vous être utiles :
+De nouveaux blocs sont ajoutés à Ethereum toutes les 12 secondes (à moins qu'un explorateur de bloc ne manque son tour), afin qu'un flux de données quasi constant soit ajouté aux explorateurs de blocs. Les blocs contiennent de nombreuses données importantes qui peuvent vous être utiles :
**Données standards**
-- Hauteur du bloc : le numéro de bloc et la longueur de la blockchain (en blocs) lors de la création du bloc actuel.
-- Horodatage : date et heure auxquelles un mineur a miné le bloc.
-- Transactions : le nombre de transactions incluses dans le bloc.
-- Mineur : l'adresse du mineur qui a miné le bloc.
-- Récompense : le montant d'ETH attribué au mineur pour avoir ajouté le bloc (récompense standard de 2 ETH + frais de transaction des transactions incluses dans le bloc).
-- Difficulté : la difficulté associée au minage du bloc.
-- Taille : la taille des données du bloc (mesurée en octets).
-- Gaz utilisé : nombre d'unités de gaz utilisées par les transactions du bloc.
-- Limite de gaz : le total des limites de gaz fixées par les transactions du bloc.
-- Données supplémentaires : toutes les données supplémentaires que le mineur a incluses dans le bloc.
+- Block height (hauteur du bloc) - Le numéro de bloc et la longueur de la blockchain (en blocs) lors de la création du bloc actuel
+- Timestamp (horodatage) - Le moment où un bloc a été proposé
+- Transactions - Le nombre de transactions incluses dans le bloc
+- Fee recipient (destinataire de frais) - L'adresse qui a reçu des conseils sur les frais de gaz lors des transactions
+- Block Reward (récompense de bloc) - Le montant d'ETH attribué au validateur qui a proposé le bloc
+- Size (taille) - La taille des données dans le bloc (mesurée en octets)
+- Gas used (gaz utilisé) - L'unité de gaz totale utilisée par les transactions dans le bloc
+- Gas limit (limite de gaz) - Les limites totales de gaz fixées par les transactions dans le bloc
+- Base fee per gas (frais de base par gaz) - Le multiplicateur minimum requis pour qu'une transaction soit incluse dans un bloc
+- Burnt fees (frais brûlés) - Combien d'ETH est brûlé dans le bloc
+- Extra data (données supplémentaires) - Toutes les données supplémentaires que le mineur a incluses dans le bloc
**Données avancées**
-- Hash : le hachage cryptographique qui représente l'en-tête du bloc (l'identifiant unique du bloc).
-- Hash parent : le hachage de bloc obtenu avant le bloc actuel.
-- Sha3Oncles : le hachage combiné de tous les oncles pour un parent donné.
-- StateRoot : la racine de l'arbre de Merkle qui contient l'état complet du système.
-- Nonce : une valeur utilisée pour démontrer la preuve de travail du mineur pour un bloc.
-
-**Blocs oncles**
-
-Des blocs oncles sont créés lorsque deux mineurs créent des blocs presque en même temps (un seul bloc pouvant être validé par les nœuds). Ils ne sont pas inclus mais génèrent quand même une récompense pour le travail.
-
-Les explorateurs de blocs fournissent les informations suivantes sur les blocs oncles :
-
-- Numéro du bloc oncle
-- Date et heure de leur création
-- Hauteur de bloc à laquelle ils ont été créés
-- Nom du mineur
-- Récompense en ETH
+- Hash (hash) - Le hachage cryptographique qui représente l'en-tête du bloc (l'identifiant unique du bloc)
+- Parent hash (hash parent) - Le hachage du bloc qui est arrivé avant le bloc actuel
+- StateRoot - Le hash racine de Merkle trie qui stocke l'état complet du système
### Gaz {#gas}
-Non seulement les explorateurs de blocs fournissent des données relatives aux blocs et à l'utilisation du gaz dans les transactions, mais certains vous donneront aussi des informations sur les prix actuels du gaz sur le réseau. Cela vous aidera à comprendre l'utilisation du réseau, à soumettre des transactions sûres et à ne pas trop dépenser en gaz. Recherchez les API qui peuvent vous aider à obtenir ces informations dans l'interface de votre produit. Les données concernant le gaz comprennent :
+Non seulement les explorateurs de blocs fournissent des données relatives à l'utilisation du gaz dans les transactions et dans les blocs, mais certains vous donneront aussi des informations sur les prix actuels du gaz sur le réseau. Cela vous aidera à comprendre l'utilisation du réseau, à soumettre des transactions sûres et à ne pas trop dépenser en gaz. Recherchez les API qui peuvent vous aider à obtenir ces informations dans l'interface de votre produit. Les données concernant le gaz comprennent :
-- une estimation du gaz nécessaire pour une transaction sécurisée, mais lente (+ une estimation du prix et de la durée de la transaction) ;
-- une estimation du gaz nécessaire pour une transaction moyenne (+ une estimation du prix et de la durée de la transaction) ;
-- une estimation du gaz nécessaire pour une transaction rapide (+ une estimation du prix et de la durée de la transaction) ;
-- un délai moyen de confirmation basé sur le prix du gaz ;
-- les contrats qui consomment du gaz (en d'autres termes, les produits populaires qui ont une forte utilisation sur le réseau) ;
-- les comptes qui consomment du gaz (en d'autres termes, les utilisateurs fréquents du réseau).
+- Unités de gaz estimées nécessaires pour une transaction sûre mais lente (+ prix estimé et durée)
+- Unités de gaz estimées nécessaires pour une transaction moyenne (+ prix estimé et durée)
+- Unités de gaz estimées nécessaires pour une transaction rapide (+ prix estimé et durée)
+- Temps de confirmation moyen basé sur le prix du gaz
+- Contrats qui consomment du gaz - en d'autres termes, des produits populaires qui voient beaucoup d'utilisation sur le réseau
+- Comptes qui dépensent du gaz - en d'autres termes, des utilisateurs fréquents du réseau
### Transactions {#transactions}
@@ -80,195 +71,176 @@ De plus en plus d'utilisateurs tirent parti des explorateurs de blocs pour suivr
**Données standards**
-- Hash de la transaction - Hash généré lorsque la transaction est soumise.
-- Statut - Indique si la transaction est en cours, a échoué ou a réussi.
-- Bloc - Bloc dans lequel la transaction a été incluse.
-- Horodatage - Moment auquel un mineur a miné la transaction.
-- De - Adresse du compte qui a soumis la transaction.
-- À - Adresse du destinataire ou du contrat intelligent avec lequel la transaction interagit.
-- Jetons transférés - Liste des jetons transférés dans le cadre de la transaction.
-- Valeur - Valeur totale en ETH de ce qui a été transféré.
-- Frais de transaction - Montant payé aux mineurs pour traiter la transaction (prix du gaz x gaz utilisé).
+- Transaction hash (hachage de la transaction) - Un hachage généré lorsque la transaction est soumise
+- Status (statut) - Une indication si la transaction est en attente, a échoué ou a réussi
+- Block (bloc) - Le bloc dans lequel la transaction a été incluse
+- Timestamp (horodatage) - Le moment où un mineur a extrait la transaction
+- From (de) - L'adresse du compte qui a soumis la transaction
+- To (à) - L'adresse du destinataire ou du contrat intelligent avec lequel la transaction interagit
+- Tokens transferred (jetons transférés) - Une liste de jetons qui ont été transférés dans le cadre de la transaction
+- Value (valeur) - La valeur ETH totale en cours de transfert
+- Transaction fee (frais de transaction) - Le montant payé au mineur pour traiter la transaction (calculé par le prix du gaz\*gaz utilisé)
**Données avancées**
-- Limite de gaz - Nombre maximum d'unités de gaz que la transaction peut consommer.
-- Gaz consommé - Montant de gaz réellement consommé par la transaction.
-- Prix du gaz - Prix fixé par unité de gaz.
-- Nonce - Numéro de transaction de l'adresse `expéditeur` (rappelez-vous que cela commence à 0, donc une once de `100` équivaut en fait à la 101ième transaction soumise par ce compte).
-- Données de saisie - Toute information supplémentaire requise par la transaction.
+- Gas limit (limite de gaz) - Le nombre maximum d'unités de gaz que cette transaction peut consommer
+- Gas used (gaz utilisé) - Le montant réel des unités de gaz consommées par la transaction
+- Gas price (prix du gaz) - Le prix fixé par unité de gaz
+- Nonce - Le numéro de transaction pour l'adresse `from` (gardez à l'esprit que cela commence à 0 donc un nonce de `100` serait en fait la 101e transaction soumise par ce compte
+- Input data (données d'entrée) - Toutes les informations supplémentaires requises par la transaction
### Comptes {#accounts}
-Il est possible d'accéder à de nombreuses données concernant un compte. C'est pourquoi il est souvent conseillé d'utiliser plusieurs comptes afin qu'il soit difficile de traquer vos capitaux et leur valeur. Plusieurs solutions sont aussi développées dans le but de rendre les transactions et l'activité d'un compte plus privée. Les données disponibles sur les comptes sont les suivantes :
+Il est possible d'accéder à de nombreuses données concernant un compte. C'est pourquoi il est souvent conseillé d'utiliser plusieurs comptes afin qu'il soit difficile de traquer vos capitaux et leur valeur. Plusieurs solutions sont aussi développées dans le but de rendre les transactions et l'activité d'un compte plus privée. Mais les données disponibles sur les comptes sont les suivantes :
**Comptes utilisateur**
-- Adresse du compte - Adresse publique que vous pouvez utiliser pour envoyer des fonds.
-- Solde ETH - Montant des ETH associés à ce compte.
-- Valeur totale des ETH - Valeur des ETH.
-- Jetons - Jetons associés au compte et leur valeur.
-- Historique des transactions - Liste de toutes les transactions pour lesquelles le compte était soit l'expéditeur soit le destinataire.
+- Account address (adresse du compte) - L'adresse publique que vous pouvez utiliser pour envoyer des fonds à
+- ETH balance (solde ETH) - Le montant d'ETH associé à ce compte
+- Valeur ETH totale (valeur ETH totale) - La valeur de l'ETH
+- Tokens (jetons) - Les jetons associés au compte et à leur valeur
+- Transaction history (historique des transactions) - Une liste de toutes les transactions où ce compte était soit l'expéditeur soit le destinataire
**Contrats intelligents**
Les comptes de contrats intelligents possèdent toutes les données d'un compte utilisateur, mais certains explorateurs de bloc afficheront aussi certaines informations liées au code. Par exemple :
-- Créateur du contrat - Adresse qui a déployé le contrat sur le réseau principal.
-- Transaction de création - Transaction qui inclut le déployement sur le réseau principal.
-- Code source - Code Solidity ou Vyper du contrat intelligent.
-- ABI du contrat - L'interface binaire d'application du contrat (les appels effectués par le contrat et les données reçues).
-- Code de création du contrat - Bytecode compilé du contrat intelligent, créé lorsque vous compilez un contrat intelligent écrit en Solidity, Vyper, etc.
-- Événements du contrat - Historique des méthodes appelées dans le contrat intelligent. Il s'agit essentiellement d'un moyen de voir comment le contrat est utilisé et à quelle fréquence.
+- Contract creator (créateur de contrat) - L'adresse qui a déployé le contrat sur le réseau principal
+- Creation transaction (transaction de création) - La transaction qui inclut le déploiement sur le réseau principal
+- Source code (code source) - La solidité ou le code vyper du contrat intelligent
+- Contract ABI (contrat IBA) - L'Interface Binaire d'Application du contrat - les appels effectués par le contrat et les données reçues
+- Contract creation code (code de création de contrat) - Le bytecode compilé du contrat intelligent, créé lorsque vous compilez un contrat intelligent écrit en Solidity ou Vyper, etc.
+- Contract events (événements du contrat) - Une histoire des méthodes appelées dans le contrat intelligent, essentiellement un moyen de voir comment le contrat est utilisé et combien de fois
### Jetons {#tokens}
-Les jetons sont un type de contrat et comporteront donc des données similaires à celles d'un contrat intelligent. Mais comme ils ont une valeur et peuvent être échangés, ils comportent des données supplémentaires :
+Les jetons sont un type de contrat, donc ils auront des données similaires à un contrat intelligent. Mais comme ils ont une valeur et peuvent être échangés, ils comportent des données supplémentaires :
-- Type - Jeton ERC-20, ERC-721 ou une autre norme de jeton.
-- Prix - S'il s'agit de jetons ERC-20, ils auront une valeur sur le marché actuel.
-- Valorisation au prix du marché - S'il s'agit de jetons ERC-20, ils feront l'objet d'une valorisation au prix du marché (prix d'un jeton x nombre total de jetons en circulation).
-- Offre totale - Le nombre total de jetons en circulation.
-- Détenteurs - Nombre d'adresses détenant le jeton.
-- Transferts : Nombre de transferts d'un jeton entre des comptes.
-- Historique des transactions - Historique de toutes les transactions effectuées incluant le jeton.
-- Adresse du contrat - Adresse du jeton qui a été déployé sur le réseau principal.
-- Décimales - Les jetons ERC-20 sont divisibles et ont des décimales.
+- Type - Qu'il s'agisse d'un ERC-20, d'un ERC-721 ou d'un autre standard de jeton
+- Price (prix) - S'il s'agit d'un ERC-20, il aura une valeur de marché actuelle
+- Market cap (capitalisation boursière) - S'il s'agit d'un ERC-20, il aura une limite de marché (calculée par le prix\*fourniture totale)
+- Total supply (fourniture totale) - Le nombre de jetons en circulation
+- Holders (titulaires) - Le nombre d'adresses qui contiennent le jeton
+- Transfers (transferts) - Le nombre de fois où le jeton a été transféré entre les comptes
+- Transaction history (historique des transactions) - Un historique de toutes les transactions y compris le jeton
+- Contract address (adresse du contrat) - L'adresse du jeton qui a été déployé sur le réseau principal
+- Decimals (décimales) - Les jetons ERC-20 sont divisibles et ont des décimales
### Réseau {#network}
-Bien sûr, certaines données parlent de la santé du réseau. Elle sont très spécifiques au mécanisme Ethereum de consensus par preuve de travail . Quand Ethereum effectuera la transition la Preuve d'enjeu certaines de ces données seront redondantes.
+Certaines données de bloc sont préoccupées par la santé d'Ethereum de manière plus globale.
-- Difficulté - Difficulté actuelle du minage.
-- Taux de hachage - Estimation du nombre de hachages générés par les mineurs Ethereum qui essayent de résoudre le bloc Ethereum actuel ou n'importe quel bloc donné.
-- Total des transactions - Nombre de transactions depuis qu'Ethereum existe.
-- Transactions par seconde - Nombre de transactions pouvant être traitées en une seconde.
-- Prix de l'ETH - Valeur actuelle d'un ETH.
-- Offre totale d'ETH - Nombre d'ETH en circulation. Rappelez-vous que des ETH sont créés avec chaque nouveau bloc sous la forme de récompenses.
-- Valorisation au prix du marché - Prix d'un ETH x l'offre totale.
+- Total transactions (total des transactions) - Le nombre de transactions depuis la création d'Ethereum
+- Transactions per second (transactions par seconde) - Le nombre de transactions pouvant être traitées en une seconde
+- ETH price (prix de l'ETH) - Les évaluations actuelles de 1 ETH
+- Total ETH supply (fourniture totale d'ETH) - Nombre d'ETH en circulation - souvenez-vous que de nouveaux ETH sont créés avec la création de chaque bloc sous la forme de récompenses de blocs
+- Market cap (capitalisation boursière) - Calcul du prix\*approvisionnement
## Données de couche de consensus {#consensus-layer-data}
-Les mises à niveau d'évolutivité sont toujours en cours de développement, mais il est intéressant de parler des points de données que les explorateurs seront capables de vous fournir. En fait, toutes ces données sont déjà disponibles pour les réseaux de test.
-
-Si vous n'êtes pas familiarisé avec la feuille de route, consultez [notre vue d'ensemble des mises à jour Ethereum](/roadmap/).
-
### Période {#epoch}
-La chaîne phare va créer aléatoirement des comités de validateurs à la fin de chaque période (toutes les 6,4 minutes) pour des raisons de sécurité. Les données de la période incluent les éléments suivants :
+Pour des raisons de sécurité, des comités aléatoires de validateurs sont créés à la fin de chaque epoch (toutes les 6,4 minutes). Les données de l'epoch incluent les éléments suivants :
-- Numéro de la période.
-- Statut de finalisation - Si la période a été finalisée (Oui/Non).
-- Temps - Moment auquel la période s'est terminée.
-- Attestations - Nombre d'attestations pendant la période (les votes pour les blocs au sein des créneaux).
-- Dépôts - Nombre d'ETH déposés dans la période (les utilisateurs doivent miser des ETH pour devenir validateurs).
-- Délestages - Nombre de pénalités infligées à ceux qui proposent ou valident les blocs.
-- Participation aux votes - Montant des ETH misés pour valider les blocs.
-- Validateurs - Nombre de validateurs actifs pour la période.
-- Solde moyen des validateurs - Solde moyen des validateurs actifs.
-- Créneaux - Nombre de créneaux inclus dans la période (les créneaux incluent un bloc valide).
+- Numéro d'epoch
+- Finalized status (statut finalisé) - Si l'epoch a été finalisée (Oui/Non)
+- Time (temps) - La date de la fin de l'epoch
+- Attestations - Le nombre d'attestations dans l'epoch (votes pour les blocs à l'intérieur des créneaux)
+- Deposits (dépôts) - Le nombre de dépôts ETH inclus à l'epoch (les validateurs doivent miser des ETH pour devenir valideurs)
+- Slashings (taillades) - Nombre de pénalités accordées aux promoteurs de blocs ou d'attestations
+- Voting participation (participation au vote) - Le montant d'ETH misé utilisé pour attester les blocs
+- Validators (validateurs) - Nombre de validateurs actifs pour l'epoch
+- Average Validator balance (solde Moyen du Validateur) - Solde moyen pour les validateurs actifs
+- Slots (créneaux) - Nombre de créneaux inclus dans l'epoch (les créneaux incluent un bloc valide)
### Créneau {#slot}
Les créneaux sont des opportunités de création de blocs. Les données disponibles pour chaque créneau comprennent les éléments suivants :
-- Période - Période pendant laquelle le créneau est valide.
-- Numéro de créneau.
-- Statut - Statut de le créneau (Proposé/Manqué).
-- Temps - Horodatage de le créneau.
-- Proposant - Validateur qui a proposé le bloc pour le créneau.
-- Block root - Le hash-tree-root de BeaconBlock.
-- Racine parente - Le hachage du bloc précédent.
-- Racine d'état - Le hash-tree-root de BeaconState.
-- Signature.
-- Randao reveal.
-- Graffiti - Quiconque soumet un bloc peut intégrer un message de 32 octets à sa proposition de bloc.
-- Données d'exécution.
- - Hash du bloc.
- - Nombre de dépôts.
- - Dépôt racine.
-- Attestations - Nombre d'attestations pour le bloc dans cet créneau.
-- Dépôts - Nombre de dépôts dans cet créneau.
-- Sorties volontaires - Nombre de validateurs qui sont partis pendant ce créneau.
-- Délestages - Nombre de pénalités infligées à ceux qui proposent ou valident les blocs.
-- Votes - Les validateurs qui ont voté pour le bloc pendant ce créneau.
+- Epoch (époque) - L'époque dans laquelle le créneau est valide
+- Numéro de créneau
+- Status (statut) - Le statut du créneau (Proposé/Manqué)
+- Time (temps) - L'horodatage du créneau
+- Proposer (proposant) - Le validateur qui a proposé le bloc pour le créneau
+- Block root (racine du bloc) - La racine du hash-tree du BeaconBlock
+- Parent root (racine parente) - Le hachage du bloc qui vient avant
+- State root (racine d'état) - La racine de hash-tree du BeaconState
+- Signature
+- Randao reveal
+- Graffiti - Un bloc proposant peut inclure un message de 32 octets à sa proposition de bloc
+- Données d'exécution
+ - Hash du bloc
+ - Nombre de dépôts
+ - Dépôt racine
+- Attestations - Nombre d'attestations pour le bloc dans ce créneau
+- Deposits (dépôts) - Le nombre de dépôts pendant ce créneau
+- Voluntary exits (sortie volontaire) - Le nombre de validateurs qui sont restés pendant le créneau
+- Slashings (taillades) - Nombre de pénalités accordées aux promoteurs de blocs ou d'attestations
+- Votes - Les validateurs qui ont voté pour le bloc de ce créneau
### Blocs {#blocks-1}
-Les blocs de couches de consensus fonctionnent différemment car les mineurs sont remplacés par les validateurs, et la chaîne phare introduit les créneaux et les périodes dans Ethereum. Cela engendre donc de nouvelles données !
+Le Proof-of-stake (la preuve de mise en jeu) divise le temps en créneaux et époques. Cela engendre donc de nouvelles données !
-- Proposant - Validateur que l'algorithme a choisi pour proposer le nouveau bloc.
-- Période - Période pendant laquelle le bloc a été proposé.
-- Créneau - Le créneau dans lequel le bloc a été proposé.
-- Attestations - Nombre d'attestation incluses dans le créneau. Les attestations sont comme des votes qui indiquent que le bloc est prêt à être intégré à la chaîne phare.
+- Proposer (proposant) - Le validateur qui a été choisi par algorithme pour proposer le nouveau bloc
+- Epoch (époque) - L'époque où le bloc a été proposé
+- Slot (emplacement) - L'emplacement dans lequel le bloc a été proposé
+- Attestations - Le nombre d'attestations incluses dans le créneau — les attestations sont comme des votes qui indiquent que le bloc est prêt à aller à la Beacon Chain (Chaîne phare)
### Validateurs {#validators}
Les validateurs doivent proposer des blocs et attester de leur conformité dans les créneaux.
-- Numéro de validateur - Numéro unique qui représente le validateur.
-- Solde actuel - Solde du validateur qui inclut les récompenses.
-- Solde effectif - Solde du validateur utilisé pour miser.
-- Revenus - Récompenses ou pénalités reçues par le validateur.
-- Statut - Détermine si le validateur est en ligne et actif ou non.
-- Attestation d'efficacité - Délai moyen nécessaire pour que les attestations du validateurs soient incluses dans la chaîne.
-- Admissibilité à l'activation - Date (et période) à laquelle le validateur est devenu disponible pour valider.
-- Actif depuis - Date (et période) à laquelle le validateur est devenu actif.
-- Blocs proposés - Blocs proposés par le validateur.
-- Attestations - Attestations fournies par le validateur.
-- Dépôts - Adresse de l'expéditeur, hash de la transaction, numéro de bloc, horodatage, montant et statut de la mise effectuée par le validateur.
+- Validator number (numéro de validateur) - Nombre unique qui représente le validateur
+- Current balance (solde actuel) - Le solde du validateur y compris les récompenses
+- Effective balance (solde effectif) - Le solde du validateur qui est utilisé pour le staking
+- Income (revenu) - Récompenses ou pénalités reçues par le validateur
+- Status (statut) - Si le validateur est actuellement en ligne et actif ou non
+- Attestation effectiveness (efficacité de l'attestation) - Le temps moyen nécessaire pour inclure les attestations du validateur dans la chaîne
+- Eligibility for activation (admissibilité à l'activation) - Date (et epoch) quand le validateur est devenu disponible pour valider
+- Active since (actif depuis) - Date (et epoch) quand le validateur est devenu actif
+- Proposed blocks (blocs proposés) - Le bloc que le validateur a proposé
+- Attestations - Les attestations que le validateur a fournies
+- Deposits (dépôts) - L'adresse, le hachage de la transaction, le numéro de bloc, l'horodatage, le montant et le statut du dépôt de staking effectué par le validateur
### Attestations {#attestations}
Les attestations sont des votes positifs pour inclure les blocs dans la chaîne. Leurs données portent sur leur enregistrement et les validateurs qui les ont émises.
-- Créneau - Créneau dans lequel l'attestation a eu lieu.
-- Index du comité - Index du comité à un créneau donné.
-- Bits d’agrégation – Représente l’attestation regroupant tous les validateurs ayant participé à l’attestation.
-- Validateurs - Validateurs qui ont fournis les attestations.
-- Racine du bloc phare - Pointe vers le bloc sur lequel les validateurs apposent leur attestation.
-- Source - Pointe vers la dernière période validée.
-- Cible - Indique la limite de période la plus récente.
-- Signature.
+- Slot (créneau) - Le créneau dans lequel l'attestation a eu lieu
+- Committee index (indice du comité) - L'indice du comité au créneau donné
+- Aggregation bits (bits d'agrégation) - Représente l'attestation agrégée de tous les validateurs participants dans l'attestation
+- Validators (validateurs) - Les validateurs qui ont fourni des attestations
+- Beacon block root (racine du bloc de balises) - Points vers le bloc auquel les validateurs sont en train d'attester
+- Source - Points de la dernière epoch justifiée
+- Target (cible) - Points à la dernière frontière de l'epoch
+- Signature
### Réseau {#network-1}
Les données de couches de consensus de haut niveau comprennent les éléments suivants :
-- Période actuelle.
-- Créneau actuel.
-- Validateurs actifs - Nombre de validateurs actifs.
-- Validateurs en attente - Nombre de validateurs attendant d'être activés.
-- ETH misés - Montant des ETH misés sur le réseau.
-- Solde moyen - Solde moyen d'ETH des validateurs.
+- epoch actuelle
+- Créneau actuel
+- Active validators (validateurs actifs) - Nombre de validateurs actifs
+- Pending validators (validateurs en attente) - Nombre de validateurs en attente d'être rendus actifs
+- Staked ETH (ETH absorbé) - Quantité d'ETH misé dans le réseau
+- Average balance (solde moyen) - Solde moyen ETH des validateurs
## Explorateurs de bloc {#block-explorers}
-- [Etherscan](https://etherscan.io/) - Explorateur de blocs que vous pouvez utiliser pour récupérer des données sur le réseau principal Ethereum ainsi que sur les réseaux de test Ropsten, Kovan, Rinkeby et Goerli.
-- [Blockscout](https://blockscout.com/) - Axé sur les réseaux suivants :
- - xDai - Combinaison intelligente du stablecoin DAI de MakerDao avec la chaîne latérale et la technologie tokenbridge de POA.
- - POA - Chaîne latérale et réseau autonome sécurisés par un groupe de validateurs de confiance. Tous les validateurs du réseau sont des notaires américains, et leurs informations sont publiquement disponibles.
- - Réseau de test POA Sokol.
- - ARTIS - Blockchain compatible avec Ethereum.
- - [LUKSO L14](https://blockscout.com/lukso/l14) - L14 fonctionne comme premier réseau de test pour permettre à la communauté LUKSO de construire et de tester une infrastructure commune.
- - qDai.
-- [Etherchain](https://www.etherchain.org/) - Explorateur de blocs pour le réseau principal Ethereum.
-- [Ethplorer](https://ethplorer.io/) - Explorateur de blocs qui se focalise sur les jetons du réseau principal Ethereum ainsi que sur le réseau de test Kovan.
-- [Blockchair](https://blockchair.com/ethereum) - L'explorateur Ethereum le plus privé. Aussi pour le tri et le filtrage des données (mempool).
-
-## Les explorateurs de blocs de la chaîne phare (couche de consensus) {#beacon-chain-block-explorers}
-
-- [https://beaconcha.in/](https://beaconcha.in/)
-- [https://beaconscan.com/](https://beaconscan.com/)
-- [https://ethscan.org/](https://ethscan.org/) (fourche de beaconcha.in)
+- [Etherscan](https://etherscan.io/) - un explorateur de blocs que vous pouvez utiliser pour récupérer des données pour le réseau principal Ethereum et le réseau de test Goerli
+- [Beaconcha.in](https://beaconcha.in/) - un explorateur de blocs open source pour le réseau principal Ethereum et le réseau de test Goerli
+- [Blockchair](https://blockchair.com/ethereum) - L'explorateur Ethereum le plus privé. Egalement pour trier et filtrer des données (mempool).
+- [Etherchain](https://www.etherchain.org/) - un explorateur de blocs pour le réseau principal Ethereum
+- [Ethplorer](https://ethplorer.io/) - un explorateur de blocs avec une focalisation sur les jetons pour le réseau principal Ethereum et le réseau de test Kovan
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
_Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
## Sujets connexes {#related-topics}
-- [Minage](/developers/docs/consensus-mechanisms/pow/mining/)
- [Transactions](/developers/docs/transactions/)
- [Comptes](/developers/docs/accounts/)
- [Réseaux](/developers/docs/networks/)
diff --git a/src/content/translations/fr/developers/docs/data-and-analytics/index.md b/src/content/translations/fr/developers/docs/data-and-analytics/index.md
index 7ece500302b..05673f7eeeb 100644
--- a/src/content/translations/fr/developers/docs/data-and-analytics/index.md
+++ b/src/content/translations/fr/developers/docs/data-and-analytics/index.md
@@ -1,35 +1,45 @@
---
-title: Données et statistiques
-description: Comment obtenir des analyses et des données sur la blockchain utiles pour votre Dapps
+title: Données et analyses
+description: Comment obtenir des analyses et des données en chaîne utiles pour vos dApps
lang: fr
---
## Introduction {#Introduction}
-À mesure que l'utilisation du réseau continue de croître, une quantité croissante d'informations précieuses existera dans les données sur la blockchain. Au fur et à mesure que le volume des données augmente, le calcul et l'assemblage de ces informations pour faire un compte-rendu ou faire fonctionner une dApp peut devenir long et nécessiter de gros efforts.
+À mesure que l'utilisation du réseau continue de croître, une quantité croissante d'informations précieuses existera dans les données en chaîne. Au fur et à mesure que le volume des données augmente, le calcul et l'assemblage de ces informations pour faire un compte rendu ou faire fonctionner une dApp peut devenir long et nécessiter de gros efforts.
Les fournisseurs de données existants peuvent accélérer le développement, produire des résultats plus précis et réduire les efforts de maintenance. Cela permettra à une équipe de se concentrer sur la fonctionnalité de base que son projet essaie de fournir.
## Pré-requis {#prerequisites}
-Vous devez comprendre le concept de base des [Explorateurs de bloc](/developers/docs/data-and-analytics/block-explorers/) afin de mieux comprendre leur utilisation dans le contexte de l'analyse des données. De plus, familiarisez-vous avec le concept d' [index](/glossary/#index) pour comprendre les avantages qu'ils apportent à la conception d'un système.
+Vous devez comprendre le concept de base des [Explorateurs de bloc](/developers/docs/data-and-analytics/block-explorers/) afin de mieux comprendre leur utilisation dans le contexte de l'analyse des données. De plus, familiarisez-vous avec le concept d'[indice](/glossary/#index) pour comprendre les avantages qu'ils apportent à la conception d'un système.
En termes de fondamentaux architecturaux, comprendre ce qu'est une [API](https://www.wikipedia.org/wiki/API) et un[REST](https://www.wikipedia.org/wiki/Representational_state_transfer) (Representational state transfer), même en théorie.
+## Explorateurs de bloc {#block-explorers}
+
+De nombreux [Explorateurs de bloc](/developers/docs/data-and-analytics/block-explorers/) offrent des passerelles [RESTful](https://www.wikipedia.org/wiki/Representational_state_transfer) [API](https://www.wikipedia.org/wiki/API) qui fournissent une visibilité aux développeurs sur les données en temps réel sur les blocs, les transactions, les mineurs, les comptes et autres activités sur la blockchain.
+
+Les développeurs peuvent alors traiter et transformer ces données afin de leur donner leurs informations d'utilisateurs uniques et leurs interactions avec la [blockchain](/glossary/#blockchain). Par exemple, [Etherscan](https://etherscan.io) fournit des données d'exécution et de consensus pour chaque créneau de 12 secondes.
+
## Le réseau Graph {#the-graph}
-Le [réseau Graph](https://thegraph.com/) est un protocole d'indexation décentralisé pour organiser les données de la blockchain. Au lieu de construire et de gérer des stockages de données hors chaîne et centralisés pour agréger les données sur la blockchain, avec The Graph, les développeurs peuvent construire des applications sans serveur qui fonctionnent entièrement sur une infrastructure publique.
+Le [réseau Graph](https://thegraph.com/) est un protocole d'indexation décentralisé pour organiser les données de la blockchain. Au lieu de construire et de gérer des stockages de données hors chaîne et centralisés pour agréger les données sur la chaîne, avec The Graph, les développeurs peuvent construire des applications sans serveur qui fonctionnent entièrement sur une infrastructure publique.
-En utilisant [GraphQL](https://graphql.org/), les développeurs peuvent interroger n'importe laquelle des API ouvertes organisées, connues sous le nom de sub-graphs, pour acquérir les informations nécessaires pour faire fonctionner leur dApp. En interrogeant ces subs-graphs indexés, les rapports et les dApps non seulement obtiennent des avantages en termes de performances et d'évolutivité, mais obtiennent aussi la précision intégrée fournie par consensus sur le réseau. Au fur et à mesure que de nouvelles améliorations et/ou sub-graphs sont ajoutées au réseau, vos projets peuvent rapidement se renouveler pour tirer parti de ces améliorations.
+En utilisant [GraphQL](https://graphql.org/), les développeurs peuvent interroger n'importe laquelle des API ouvertes organisées, connues sous le nom de sub-graphe, pour acquérir les informations nécessaires pour faire fonctionner leur dApp. En interrogeant ces subs-graphs indexés, les rapports et les dApps non seulement obtiennent des avantages en termes de performances et d'évolutivité, mais obtiennent aussi la précision intégrée fournie par consensus sur le réseau. Au fur et à mesure que de nouvelles améliorations et/ou sub-graphs sont ajoutées au réseau, vos projets peuvent rapidement se renouveler pour tirer parti de ces améliorations.
-## Explorateurs de bloc {#block-explorers}
+## Diversité des clients
-De nombreux [Explorateurs de bloc](/developers/docs/data-and-analytics/block-explorers/) offrent des passerelles [RESTful](https://www.wikipedia.org/wiki/Representational_state_transfer) [API](https://www.wikipedia.org/wiki/API) qui fournissent une visibilité aux développeurs sur les données en temps réel sur les blocs, les transactions, les mineurs, les comptes et autres activités sur la blockchain.
+[La diversité du client](/developers/docs/nodes-and-clients/client-diversity/) est importante pour la santé globale du réseau Ethereum, car elle fournit de la résilience aux bogues et aux exploitations. Il y a maintenant plusieurs tableaux de bord de diversité de clients dont [clientdiversity.org, [rated.etwork](rated.network), [execution-diversity.info](https://execution-diversity.info/), [](https://ethernodes.org/) et Ethernodes](https://clientdiversity.org/).
+
+## Dune Analytics {#dune-analytics}
-Les développeurs peuvent alors traiter et transformer ces données afin de leur donner leurs informations d'utilisateurs uniques et leurs interactions avec la [blockchain](/glossary/#blockchain).
+[Dune Analytics](https://dune.com/) prétraite les données de la blockchain en tables de base de données relationnelles (PostgreSQL et DatabricksSQL), permet aux utilisateurs d'interroger les données de la blockchain en utilisant SQL et de construire des tableaux de bord basés sur les résultats des requêtes. Les données sur la chaîne sont réparties en 4 tables brutes : `blocs`, `transactions`, (événement) `logs` et (appel) `traces`. Les contrats et protocoles populaires ont été décodés et chacun a son propre ensemble de tables d'événements et d'appels. Ces tables d'événements et d'appels sont traitées et organisées en tables d'abstraction par le type de protocoles, par exemple, dex, prêt, stablecoins, etc.
## Complément d'information {#further-reading}
- [Présentation du réseau Graph](https://thegraph.com/docs/en/about/network/)
- [Bac à sable de requêtes Graph](https://thegraph.com/explorer/subgraph/graphprotocol/graph-network-mainnet?version=current)
- [Examples de code d'APIs sur EtherScan](https://etherscan.io/apis#contracts)
+- [Explorateur de Beacon Chain](https://beaconcha.in)
+- [Basiques de Dune](https://docs.dune.com/#dune-basics)
diff --git a/src/content/translations/fr/developers/docs/development-networks/index.md b/src/content/translations/fr/developers/docs/development-networks/index.md
index eed821e54e9..99698d1a813 100644
--- a/src/content/translations/fr/developers/docs/development-networks/index.md
+++ b/src/content/translations/fr/developers/docs/development-networks/index.md
@@ -6,27 +6,27 @@ lang: fr
Quand vous construirez une application Ethereum avec des contrats intelligents, vous voudrez l'exécuter sur un réseau local pour vérifier son fonctionnement avant de la déployer.
-De la même façon que vous exécuteriez un serveur local sur votre ordinateur pour du développement Web, vous pouvez utiliser un réseau de développement pour créer une occurrence de blockchain locale et tester votre application décentralisée (DApp). Ces réseaux de développement Ethereum fournissent des fonctionnalités permettant une itération beaucoup plus rapide qu'un réseau de test public (par exemple, vous n'avez pas à gérer l'acquisition d'ETH depuis le robinet d'un réseau de test).
+De la même façon que vous exécuteriez un serveur local sur votre ordinateur pour du développement Web, vous pouvez utiliser un réseau de développement pour créer une occurrence de blockchain locale et tester votre application décentralisée (dApp). Ces réseaux de développement Ethereum fournissent des fonctionnalités permettant une itération beaucoup plus rapide qu'un réseau de test public (par exemple, vous n'avez pas à gérer l'acquisition d'ETH depuis le robinet d'un réseau de test).
## Prérequis {#prerequisites}
Vous devrez comprendre les [bases de la pile Ethereum](/developers/docs/ethereum-stack/) et des [réseaux Ethereum](/developers/docs/networks/) avant de vous plonger dans les réseaux de développement.
-## Qu'est-ce qu'un réseau de développement? {#what-is-a-development-network}
+## Qu'est-ce qu'un réseau de développement ? {#what-is-a-development-network}
Les réseaux de développement sont essentiellement des clients Ethereum (implémentations d'Ethereum) spécifiquement conçus pour le développement local.
**Pourquoi ne pas juste exécuter un nœud Ethereum standard localement ?**
-Vous _pourriez_ [ exécuter un nœud](/developers/docs/nodes-and-clients/#running-your-own-node) (tels que Geth, Erigon, ou Nethermind) mais puisque les réseaux de développement sont conçus pour le développement, ils sont souvent fournis avec des fonctionnalités pratiques telles que:
+Vous _pourriez_ [ exécuter un nœud](/developers/docs/nodes-and-clients/#running-your-own-node) mais puisque les réseaux de développement sont conçus pour le développement, ils sont souvent fournis avec des fonctionnalités pratiques telles que :
- Alimentation déterminée de votre blockchain locale avec des données (par exemple, des comptes avec des soldes d'ETH)
-- Minage instantané de blocs avec chaque transaction reçue, dans l'ordre et sans délai
-- Fonctionnalités de débogage et de consignation améliorées
+- Production instantanée de blocs avec chaque transaction reçue, dans l'ordre et sans délai
+- Fonctionnalités de débogage et de logging améliorées
## Outils disponibles {#available-projects}
-**Remarque** : La plupart des [frameworks de développement](/developers/docs/frameworks/) incluent un réseau de développement intégré. Nous recommandons de démarrer avec un framework pour [configurer votre environnement de développement local](/developers/local-environment/).
+**Remarque** : La plupart des [cadres de développement](/developers/docs/frameworks/) incluent un réseau de développement intégré. Nous recommandons de démarrer avec un cadre pour [configurer votre environnement de développement local](/developers/local-environment/).
### Ganache {#ganache}
@@ -47,6 +47,21 @@ Le réseau Hardhat est intégré avec Hardhat, un environnement de développemen
- [Site Web](https://hardhat.org/)
- [GitHub](https://github.com/nomiclabs/hardhat)
+### Chaînes phares locales {#local-beacon-chains}
+
+Certains clients de consensus disposent d'outils intégrés pour faire tourner les chaînes phares locales à des fins de test. Les instructions pour Lighthouse, Nimbus et Lodestar sont disponibles ici :
+
+- [Réseau de test local utilisant Lodestar](https://chainsafe.github.io/lodestar/usage/local/)
+- [Réseau de test local utilisant Lighthouse](https://lighthouse-book.sigmaprime.io/setup.html#local-testnets)
+- [Réseau de test local utilisant Nimbus](https://github.com/status-im/nimbus-eth1/blob/master/fluffy/docs/local_testnet.md)
+
+### Chaînes publiques de test pour Ethereum {#public-beacon-testchains}
+
+Il y a aussi deux implémentations de test publiques maintenues d'Ethereum : Goerli et Sepolia. Le réseau testnet recommandé avec support à long terme est Goerli, que tout le monde est libre de valider. Sepolia est une nouvelle chaîne plus petite et devrait également être maintenue dans un avenir proche, avec un ensemble de validateurs autorisés (ce qui signifie qu'il n'y a pas d'accès général aux nouveaux validateurs sur ce réseau de test). La chaîne Ropsten devrait être dépréciée au quatrième trimestre 2022, et la chaîne Rinkeby devrait être dépréciée aux T2/T3 2023.
+
+- [Plateforme de lancement de la mise en jeu de Goerli](https://goerli.launchpad.ethereum.org/)
+- [Ropsten, Rinkeby & Annonce de dépréciation Kiln](https://blog.ethereum.org/2022/06/21/testnet-deprecation)
+
## Complément d'information {#further-reading}
_Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
diff --git a/src/content/translations/fr/developers/docs/ethereum-stack/index.md b/src/content/translations/fr/developers/docs/ethereum-stack/index.md
index c392cc20a81..20257e110ac 100644
--- a/src/content/translations/fr/developers/docs/ethereum-stack/index.md
+++ b/src/content/translations/fr/developers/docs/ethereum-stack/index.md
@@ -10,11 +10,11 @@ Il existe cependant des technologies Ethereum de base qui contribuent à fournir
## Niveau 1: Machine virtuelle Ethereum {#ethereum-virtual-machine}
-La [machine virtuelle Ethereum (EVM)](/developers/docs/evm/) est l'environnement d'exécution des contrats intelligents Ethereum. Tout contrat intelligent et changement d'état sur la blockchain Ethereum sont exécutés par des [transactions](/developers/docs/transactions/). L'EVM gère l'ensemble du traitement des transactions sur le réseau Ethereum.
+La [machine virtuelle Ethereum (EVM)](/developers/docs/evm/) est l'environnement d'exécution des contrats intelligents sur Ethereum. Tout contrat intelligent et changement d'état sur la blockchain Ethereum sont exécutés par des [transactions](/developers/docs/transactions/). L'EVM gère l'ensemble du traitement des transactions sur le réseau Ethereum.
Comme toute machine virtuelle, l'EVM crée un niveau d'abstraction entre l'exécution du code et la machine qui l'exécute (un nœud Ethereum). Actuellement, l'EVM s'exécute sur des milliers de nœuds répartis à travers le monde.
-De façon non visible, l'EVM utilise un ensemble d'instructions de codes d'opérations (opcodes) pour exécuter des tâches spécifiques. Ces 140 opcodes uniques permettent à l'EVM d'être Turing-complet, ce qui signifie qu'elle est capable de calculer à peu près tout, à partir du moment où elle dispose des ressources suffisantes.
+De façon non visible, l'EVM utilise un ensemble d'instructions de codes d'opérations (opcodes) pour exécuter des tâches spécifiques. Ces 140 op codes (uniques) permettent à l'EVM d'être [Turing-complete](https://en.wikipedia.org/wiki/Turing_completeness), ce qui signifie que l'EVM est capable de calculer à peu près n'importe quoi, compte tenu de ressources suffisantes.
En tant que développeur de DApp, vous n'avez pas besoin d'en savoir beaucoup plus sur l'EVM, à part qu'elle existe et qu'elle assure de façon fiable le bon fonctionnement des applications sur Ethereum sans temps d'arrêt.
@@ -24,7 +24,7 @@ En tant que développeur de DApp, vous n'avez pas besoin d'en savoir beaucoup pl
Les contrats intelligents sont rédigés avec des [langages de programmation](/developers/docs/smart-contracts/languages/) spécifiques qui se compilent en bytecode EVM (instructions machine de bas niveau appelées codes d'opérations).
-Non seulement les contrats intelligents servent de bibliothèques open source, mais ce sont aussi essentiellement des services API ouverts fonctionnant / qui ne peuvent être arrêtés. Les contrats intelligents fournissent des fonctions publiques avec lesquelles les utilisateurs et les applications ([dApps](/developers/docs/dapps/)) peuvent interagir sans nécessiter d'autorisation. Toute application peut s'intégrer à des contrats intelligents déployés pour composer des fonctionnalités, telles que l'ajout de [flux de données](/developers/docs/oracles/) ou la prise en charge des échanges de jetons. N'importe qui peut déployer de nouveaux contrats intelligents sur Ethereum pour ajouter des fonctionnalités personnalisées et répondre aux besoins de son application.
+Non seulement les contrats intelligents servent de bibliothèques open source, mais ce sont aussi essentiellement des services API ouverts fonctionnant 24/7 qui ne peuvent être arrêtés. Les contrats intelligents fournissent des fonctions publiques avec lesquelles les utilisateurs et les applications ([dApps](/developers/docs/dapps/)) peuvent interagir sans nécessiter d'autorisation. Toute application peut s'intégrer à des contrats intelligents déployés pour composer des fonctionnalités, telles que l'ajout de [flux de données](/developers/docs/oracles/) ou la prise en charge des échanges de jetons. N'importe qui peut déployer de nouveaux contrats intelligents sur Ethereum pour ajouter des fonctionnalités personnalisées et répondre aux besoins de son application.
En tant que développeur de dApp, vous n'aurez besoin de rédiger des contrats intelligents que si vous voulez ajouter des fonctionnalités personnalisées sur la blockchain Ethereum. Vous constaterez que vous pouvez réaliser la plupart ou la totalité de vos projets seulement en intégrant des contrats intelligents existants, par exemple si vous voulez encourager les paiements en stablecoins ou faciliter l'échange décentralisé de jetons.
@@ -42,7 +42,7 @@ De nombreuses bibliothèques pratiques (construites et maintenues par la communa
Si votre application orientée utilisateur est une application Web, vous pouvez choisir de `npm install` une [API JavaScript](/developers/docs/apis/javascript/) directement sur votre frontend, ou préférerez peut-être implémenter cette fonctionnalité côté serveur, avec une API [Python](/developers/docs/programming-languages/python/) ou [Java](/developers/docs/programming-languages/java/).
-Alors que ces API ne sont pas des éléments indispensables de la pile, elles éliminent une grande partie de la complexité d'intéragir directement avec un nœud Ethereum. Elles fournissent également des fonctions utilitaires (par ex. convertir des ETH en gwei) afin que vous puissiez, en tant que développeur, passer moins de temps à gérer les subtilités des clients Ethereum et plus de temps à vous consacrer aux fonctionnalités uniques de votre application.
+Alors que ces API ne sont pas des éléments indispensables de la pile, elles éliminent une grande partie de la complexité d'intéragir directement avec un nœud Ethereum. Elles fournissent également des fonctions utilitaires (par ex., convertir des ETH en gwei) afin que vous puissiez, en tant que développeur, passer moins de temps à gérer les subtilités des clients Ethereum et plus de temps à vous consacrer aux fonctionnalités uniques de votre application.
## Niveau 5 : Applications utilisateur {#end-user-applications}
diff --git a/src/content/translations/fr/developers/docs/frameworks/index.md b/src/content/translations/fr/developers/docs/frameworks/index.md
index 1b8208a9597..0a6d47d37ad 100644
--- a/src/content/translations/fr/developers/docs/frameworks/index.md
+++ b/src/content/translations/fr/developers/docs/frameworks/index.md
@@ -11,12 +11,12 @@ La construction d'une dApp complète nécessite différentes technologies. Les i
Ces infrastructures sont livrés avec de nombreuses fonctionnalités prêtes à l'emploi :
- Fonctionnalités pour faire tourner une instance locale de la blockchain.
-- Des utilitaires pour compiler et tester vos contrats intelligents.
+- Utilitaires pour compiler et tester vos contrats intelligents.
- Modules de développement client pour construire votre application orientée utilisateur au sein du même projet/référentiel.
- Configuration pour se connecter aux réseaux Ethereum et déployer des contrats, que ce soit sur une instance exécutée localement ou sur l'un des réseaux publics Ethereum.
- Distribution d'applications décentralisées, intégration à des options de stockage comme IPFS.
-## Pré-requis {#prerequisites}
+## Prérequis {#prerequisites}
Avant de plonger dans les infrastructures, nous vous recommandons de commencer par lire notre introduction aux [dApps](/developers/docs/dapps/) et à la [pile Ethereum](/developers/docs/ethereum-stack/).
@@ -46,24 +46,29 @@ Avant de plonger dans les infrastructures, nous vous recommandons de commencer p
- [Page d'accueil](https://www.web3labs.com/web3j-sdk)
- [Documentation](https://docs.web3j.io)
-- [GitHub](https://github.com/web3j/web3j)
+- [Github](https://github.com/web3j/web3j)
-**OpenZeppelin SDK -** **_La suite d'outils par excellence pour vous aider à développer, compiler, mettre à niveau, déployer et interagir avec des contrats intelligents._**
+**OpenZeppelin SDK - \*\***_The Ultimate Smart Contract Toolkit : la suite d'outils par excellence pour vous aider à développer, compiler, mettre à niveau, déployer et interagir avec des contrats intelligents._\*\*
- [OpenZeppelin SDK](https://openzeppelin.com/sdk/)
-- [GitHub](https://github.com/OpenZeppelin/openzeppelin-sdk)
+- [Github](https://github.com/OpenZeppelin/openzeppelin-sdk)
- [Forum communautaire](https://forum.openzeppelin.com/c/support/17)
-**Créer une application Eth -** **_Créer des applications alimentées par Ethereum avec une seule commande. Fournit un panel d'infrastructures d'interface utilisateur et des modèles DeFi parmi lesquels faire votre choix._**
+**Create Eth App -** **_Création d'applications alimentées par Ethereum en une seule commande. Fournit un panel d'infrastructures d'interface utilisateur et des modèles DeFi parmi lesquels faire votre choix._**
-- [GitHub](https://github.com/paulrberg/create-eth-app)
-- [Modèles](https://github.com/PaulRBerg/create-eth-app/tree/develop/templates)
+- [Github](https://github.com/paulrberg/create-eth-app)
+- [Modèles (Templates)](https://github.com/PaulRBerg/create-eth-app/tree/develop/templates)
**Scaffold-eth -** **_Les composants Ethers.js + Hardhat + React et les boucles pour web3 : tout ce dont vous avez besoin pour commencer à bâtir des applications décentralisées alimentées par des contrats intelligents._**
- [GitHub](https://github.com/austintgriffith/scaffold-eth)
-**Le graphique -** **_Le graphique pour interroger efficacement les données de la blockchain._**
+**Probablement -** **_Plateforme de développement Web3 qui permet aux développeurs de blockchain de construire, tester, déboger, surveiller et gérer des contrats intelligents et améliorer la dApp UX._**
+
+- [Site Web](https://tenderly.co/)
+- [Documentation](https://docs.tenderly.co/ethereum-development-practices)
+
+**The Graph -** **_Le graphique pour interroger efficacement les données de la blockchain._**
- [Site Web](https://thegraph.com/)
- [Tutoriel](/developers/tutorials/the-graph-fixing-web3-data-querying/)
@@ -71,7 +76,7 @@ Avant de plonger dans les infrastructures, nous vous recommandons de commencer p
**Alchemy -** **_Plateforme de développement Ethereum._**
- [alchemy.com](https://www.alchemy.com/)
-- [GitHub](https://github.com/alchemyplatform)
+- [Github](https://github.com/alchemyplatform)
- [Discord](https://discord.com/invite/A39JVCM)
**Foundry -** **_Une boîte à outils rapide, portable et modulaire pour le développement d'applications Ethereum écrites en Rust._**
@@ -80,6 +85,12 @@ Avant de plonger dans les infrastructures, nous vous recommandons de commencer p
- [GitHub](https://github.com/gakonst/foundry/)
- [Outils pour Foundry](https://github.com/crisgarner/awesome-foundry)
+**NodeReal -** **_Plateforme de développement Ethereum._**
+
+- [Nodereal.io](https://nodereal.io/)
+- [GitHub](https://github.com/node-real)
+- [Discord](https://discord.gg/V5k5gsuE)
+
## Complément d'information {#further-reading}
_Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
diff --git a/src/content/translations/fr/developers/docs/ides/index.md b/src/content/translations/fr/developers/docs/ides/index.md
index 17adfe2359d..c8f49a73798 100644
--- a/src/content/translations/fr/developers/docs/ides/index.md
+++ b/src/content/translations/fr/developers/docs/ides/index.md
@@ -10,28 +10,31 @@ Lorsqu'il s'agit de configurer un [environnement de développement intégré (ID
Si vous cherchez à manipuler du code avant de [configurer un environnement de développement local](/developers/local-environment/), ces applications Web sont conçues sur mesure pour le développement de contrats intelligents Ethereum.
-**Remix -** **_IDE basé sur le Web avec analyse statique intégrée et une machine virtuelle de test de blockchain._**
+**[Remix](https://remix.ethereum.org/)** - **_IDE basé sur le Web avec une analyse statique, et une machine virtuelle de test de la blockchain_**
-- [remix.ethereum.org](https://remix.ethereum.org/)
+- [Documentation](https://remix-ide.readthedocs.io/en/latest/#)
+- [Gitter](https://gitter.im/ethereum/remix)
-**EthFiddle -** **_IDE Web permettant de rédiger, de compiler et de déboguer vos contrats intelligents._**
+**[ChainIDE](https://chainide.com/)** - **_Un IDE multichaîne basée sur le cloud_**
-- [ethfiddle.com](https://ethfiddle.com/)
-- [Gitter](https://gitter.im/loomnetwork/ethfiddle)
+- [Documentation](https://chainide.gitbook.io/chainide-english-1/)
+- [Forum d'aide](https://forum.chainide.com/)
+
+**[Replit (Starter Solidity - Beta)](https://replit.com/@replit/Solidity-starter-beta)** - **_Un environnement de développement personnalisable pour Ethereum avec rechargement, vérification d'erreur et support natif des réseaux de test._**
-**ChainIDE -** **_IDE multi chaîne orienté Cloud_**
+- [Documentation](https://docs.replit.com/)
-- [chainide.com](https://chainide.com/)
+**[Bac à sable Tenderly](https://sandbox.tenderly.co/)** - **_Un environnement de prototypage rapide où vous pouvez écrire, exécuter, et déboguer les contrats intelligents dans le navigateur en utilisant Solidity et JavaScript_**
-**Replit : ** **_Un environnement de développement personnalisable pour Ethereum avec rechargement, vérification d'erreur et une assistance de première classe au réseau de tests._**
+**[EthFiddle](https://ethfiddle.com/)** - **_IDE basé sur le Web qui vous permet d'écrire, de compiler et de déboguer votre contrat intelligent._**
-- [Démarreur Solidity](https://replit.com/@replit/Solidity-starter-beta)
+- [Gitter](https://gitter.im/loomnetwork/ethfiddle)
## IDE de bureau {#desktop-ides}
-La plupart des IDE ont construit des plugins pour améliorer l'expérience de développement Ethereum. Au minimum, ils fournissent un éclairage syntaxique sur les [langages des contrats intelligents](/developers/docs/smart-contracts/languages/).
+La plupart des IDE ont permis de construire des plugins pour améliorer l'expérience de développement Ethereum. Au minimum, ils fournissent un éclairage syntaxique sur les [langages des contrats intelligents](/developers/docs/smart-contracts/languages/).
-**Visual Studio Code -** **_IDE professionnel multiplateforme avec support officiel Ethereum._**
+**Visual Studio Code -** **_IDE professionnel multiplateforme avec le support officiel d'Ethereum._**
- [Visual Studio Code](https://code.visualstudio.com/)
- [Plan de travail blockchain Azure](https://azuremarketplace.microsoft.com/en-us/marketplace/apps/microsoft-azure-blockchain.azure-blockchain-workbench?tab=Overview)
@@ -58,6 +61,7 @@ La plupart des IDE ont construit des plugins pour améliorer l'expérience de d
## Plugins et extensions {#plugins-extensions}
- [Solidity](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity) - Ethereum Solidity Language for Visual Studio Code
+- [Solidity + Hardhat pour VS Code](https://marketplace.visualstudio.com/items?itemName=NomicFoundation.hardhat-solidity) - Prise en charge de Solidity et Hardhat par l'équipe Hardhat
- [Prettier Solidity](https://github.com/prettier-solidity/prettier-plugin-solidity) - Formateur de code utilisant prettier
## Complément d'information {#further-reading}
diff --git a/src/content/translations/fr/developers/docs/programming-languages/dart/index.md b/src/content/translations/fr/developers/docs/programming-languages/dart/index.md
index e92b926938a..eaa11246a2e 100644
--- a/src/content/translations/fr/developers/docs/programming-languages/dart/index.md
+++ b/src/content/translations/fr/developers/docs/programming-languages/dart/index.md
@@ -5,18 +5,18 @@ lang: fr
incomplete: true
---
-## Premiers pas avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity}
+## Débuter avec les Contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity}
## Tutos {#tutorials}
-- [Flutter et blockchain – dApp Hello World](https://www.geeksforgeeks.org/flutter-and-blockchain-hello-world-dapp/) vous emmène à travers toutes les étapes pour bien débuter :
+- [Flutter et blockchain – la dApp Hello World](https://www.geeksforgeeks.org/flutter-and-blockchain-hello-world-dapp/) vous emmène à travers toutes les étapes pour bien débuter :
1. Installer la suite de développement [Truffle](https://www.trufflesuite.com/)
2. Écrire un contrat intelligent avec [Solidity](https://soliditylang.org/)
3. Écrire une interface utilisateur avec Dart
-- [Créer une dApp mobile avec Flutter](https://medium.com/dash-community/building-a-mobile-dapp-with-flutter-be945c80315a) est beaucoup plus court, ce qui pourrait mieux convenir si vous connaissez déjà les bases.
+- [Créer une dApp mobile avec Flutter](https://medium.com/dash-community/building-a-mobile-dapp-with-flutter-be945c80315a) est beaucoup plus court, ce qui pourrait mieux convenir si vous connaissez déjà les bases
- Si vous préférez apprendre en regardant une vidéo, vous pouvez regarder [Elaborez votre première App Blockchain avec Flutter](https://www.youtube.com/watch?v=3Eeh3pJ6PeA), en une heure.
- Si vous êtes impatient, vous préférerez peut-être [créer une application décentralisée blockchain avec Flutter et Dart sur Ethereum](https://www.youtube.com/watch?v=jaMFEOCq_1s), en seulement vingt minutes.
-- [Intégrer MetaMask dans l'application Flutter](https://youtu.be/8qzVDje3IWk) - cette courte vidéo vous permet étape par étape d'intégrer MetaMask dans vos applications Flutte.
+- [Intégrer MetaMask dans l'application Flutter](https://youtu.be/8qzVDje3IWk) - cette courte vidéo vous permet étape par étape d'intégrer MetaMask dans vos applications Flutter
## Travailler avec des clients Ethereum {#working-with-ethereum-clients}
diff --git a/src/content/translations/fr/developers/docs/programming-languages/delphi/index.md b/src/content/translations/fr/developers/docs/programming-languages/delphi/index.md
index c7b005d42e9..d193fc18c56 100644
--- a/src/content/translations/fr/developers/docs/programming-languages/delphi/index.md
+++ b/src/content/translations/fr/developers/docs/programming-languages/delphi/index.md
@@ -11,7 +11,7 @@ Apprendre à développer pour Ethereum avec le langage de programmation Delphi
-Utilisez Ethereum pour créer des applications décentralisées (ou « dapps ») qui bénéficient des avantages des crypto-monnaies et de la technologie blockchain. Ces dapps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune entité ou personne ne les contrôle et qu'il est pratiquement impossible de les censurer.
+Utilisez Ethereum pour créer des applications décentralisées (ou « dApps ») qui tirent parti de la technologie de la blockchain et des cryptomonnaies. Ces dApps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune personne ni entité ne les contrôle et qu'il est pratiquement impossible de les censurer.
Créez des applications décentralisées sur Ethereum et interagissez avec des contrats intelligents en utilisant le langage de programmation Delphi !
@@ -22,7 +22,7 @@ Créez des applications décentralisées sur Ethereum et interagissez avec des c
Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/).
- [Explication de la blockchain](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
-- [Comprendre les contrats autonomes](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [Comprendre les contrats intelligents](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
- [Écrire votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
- [Apprendre à compiler et à déployer avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
@@ -40,7 +40,7 @@ Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/lea
- [Un contrat intelligent de 3 minutes et Delphi : 1ère partie](https://medium.com/@svanas/a-3-minute-smart-contract-and-delphi-61d998571d)
- [Un contrat intelligent de 3 minutes et Delphi : 2ème partie](https://medium.com/@svanas/a-3-minute-smart-contract-and-delphi-part-2-446925faa47b)
-## Articles de niveau intermédiaire {#intermediate-articles}
+## Articles intermédiaires {#intermediate-articles}
- [Génération d'une signature de message signée par Ethereum dans Delphi](https://medium.com/@svanas/generating-an-ethereum-signed-message-signature-in-delphi-75661ce5031b)
- [Transfert d'éther avec Delphi](https://medium.com/@svanas/transferring-ether-with-delphi-b5f24b1a98a4)
@@ -51,5 +51,6 @@ Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/lea
- [Delphi et Ethereum Name Service (ENS)](https://medium.com/@svanas/delphi-and-ethereum-name-service-ens-4443cd278af7)
- [QuikNode, Ethereum et Delphi](https://medium.com/@svanas/quiknode-ethereum-and-delphi-f7bfc9671c23)
- [Delphi et la forêt sombre d'Ethereum](https://svanas.medium.com/delphi-and-the-ethereum-dark-forest-5b430da3ad93)
+- [Échanger un jeton contre un autre avec Delphi](https://svanas.medium.com/swap-one-token-for-another-in-delphi-bcb999c47f7)
Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers.](/developers/).
diff --git a/src/content/translations/fr/developers/docs/programming-languages/dot-net/index.md b/src/content/translations/fr/developers/docs/programming-languages/dot-net/index.md
index 46b5163e8ed..636412c4d2a 100644
--- a/src/content/translations/fr/developers/docs/programming-languages/dot-net/index.md
+++ b/src/content/translations/fr/developers/docs/programming-languages/dot-net/index.md
@@ -1,13 +1,13 @@
---
title: Ethereum pour les développeurs .NET
-description: Apprendre à développer sur Ethereum avec des projets et des outils basés sur .NET
+description: Apprendre à développer pour Ethereum avec des projets et des outils basés sur .NET
lang: fr
incomplete: true
---
Apprendre à développer pour Ethereum avec des projets et des outils basés sur .NET
-Utilisez Ethereum pour créer des applications décentralisées (ou « dapps ») qui bénéficient des avantages des crypto-monnaies et de la technologie blockchain. Ces dapps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune entité ou personne ne les contrôle et qu'il est pratiquement impossible de les censurer.
+Utilisez Ethereum pour créer des applications décentralisées (ou « dApps ») qui tirent parti de la technologie de la blockchain et des cryptomonnaies. Ces dApps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune personne ni entité ne les contrôle et qu'il est pratiquement impossible de les censurer.
Construisez des applications décentralisées sur Ethereum et interagissez avec des contrats intelligents en utilisant les outils et les langages de la pile technologique Microsoft, qui prend en charge C#, # Visual Basic .NET, F# dans des environnements comme VSCode et Visual Studio sur .NET Framework/.NET Core/.NET Standard. Déployez une blockchain Ethereum sur Azure en quelques minutes en utilisant Microsoft Azure Blockchain. Continuez votre histoire d'amour avec .NET sur Ethereum !
@@ -18,7 +18,7 @@ Construisez des applications décentralisées sur Ethereum et interagissez avec
Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/).
- [Explication de la blockchain](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
-- [Comprendre les contrats autonomes](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [Comprendre les contrats intelligents](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
- [Écrire votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
- [Apprendre à compiler et à déployer avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
@@ -43,7 +43,7 @@ Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/lea
- Transférer de l'ether sur un compte [C#](http://playground.nethereum.com/csharp/id/1003) [VB.NET](http://playground.nethereum.com/vb/id/2003)
- ... Et bien plus encore !
-## Articles de niveau intermédiaire {#intermediate-articles}
+## Articles intermédiaires {#intermediate-articles}
- [Classeur/liste d'échantillons de Nethereum](http://docs.nethereum.com/en/latest/Nethereum.Workbooks/docs/)
- [Déployer vos propres chaînes de test de développement](https://github.com/Nethereum/Testchains)
@@ -68,7 +68,7 @@ Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/lea
- [Nethereum Codegen Blazor](https://github.com/Nethereum/Nethereum.CodeGen.Blazor) - _Générateur de code Nethereum C avec interface en Blazor_
- [Nethereum Blazor](https://github.com/Nethereum/NethereumBlazor) - _Explorateur de blockchain Wasm SPA .NET léger et portefeuille simple_
- [Wonka Business Rules Engine](https://docs.nethereum.com/en/latest/wonka/) - _Moteur de règles commerciales (pour les plateformes .NET et Ethereum) intrinsèquement basé sur les métadonnées_
-- [Nethermind](https://github.com/NethermindEth/nethermind) - _Client Ethereum Core .NET pour Linux, Windows, MacOs_
+- [Nethermind](https://github.com/NethermindEth/nethermind) - _Client Ethereum Core .NET pour Linux, Windows, macOS_
- [eth-utils](https://github.com/ethereum/eth-utils/) - _Fonctions utilitaires pour travailler avec les bases de code liées à Ethereum_
- [TestChains](https://github.com/Nethereum/TestChains) - _Chaînes de développement .NET préconfigurées pour une réponse rapide (PoA)_
@@ -76,9 +76,9 @@ Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers.](/d
## Contributeurs de la Communauté .NET {#dot-net-community-contributors}
-Chez Nethereum, on se retrouve principalement sur [Gitter](https://gitter.im/Nethereum/Nethereum), où tout le monde est le bienvenu pour poser des questions et y répondre, obtenir de l'aide ou tout simplement se détendre. N'hésitez pas à faire une PR ou à ouvrir un ticket sur le dépôt [GitHub Nethereum](https://github.com/Nethereum), ou simplement à parcourir les nombreux projets/échantillons disponibles. Vous pouvez également nous trouver sur [Discord](https://discord.gg/jQPrR58FxX) !
+Chez Nethereum, on se retrouve principalement sur [Gitter](https://gitter.im/Nethereum/Nethereum), où tout le monde est le bienvenu pour poser des questions et y répondre, obtenir de l'aide ou tout simplement se détendre. N'hésitez pas à créer une PR ou à ouvrir un ticket sur le dépôt [GitHub Nethereum](https://github.com/Nethereum), ou simplement à parcourir les nombreux projets/échantillons disponibles. Vous pouvez également nous trouver sur [Discord](https://discord.gg/jQPrR58FxX) !
-Retrouvez Nethermind sur [Gitter](https://gitter.im/nethermindeth/nethermind). Pour tout problème ou PR, consultez le dépôt [GitHub Nethermind](https://github.com/NethermindEth/nethermind).
+Si vous êtes nouveau chez Nethermind et avez besoin d'aide pour débuter, rejoignez notre [Discord](http://discord.gg/PaCMRFdvWT). Nos développeurs sont à votre disposition pour répondre à vos questions. N'hésitez pas à ouvrir une PR ou à signaler des problèmes sur le répertoire [GitHub de Nethermind](https://github.com/NethermindEth/nethermind).
## Autres ressources {#other-aggregated-lists}
diff --git a/src/content/translations/fr/developers/docs/programming-languages/golang/index.md b/src/content/translations/fr/developers/docs/programming-languages/golang/index.md
index e83a7625b8f..ac743a8ce9f 100644
--- a/src/content/translations/fr/developers/docs/programming-languages/golang/index.md
+++ b/src/content/translations/fr/developers/docs/programming-languages/golang/index.md
@@ -1,13 +1,13 @@
---
title: Ethereum pour les développeurs Go
-description: Apprendre à développer sur Ethereum avec des projets et des outils basés sur Go
+description: Apprendre à développer pour Ethereum avec des projets et des outils basés sur Go
lang: fr
incomplete: true
---
Apprendre à développer pour Ethereum avec des projets et des outils basés sur Go
-Utilisez Ethereum pour créer des applications décentralisées (ou « dApps »). Ces dapps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Étant décentralisées, elles fonctionnent sur un réseau P2P et il n'existe aucun point de défaillance. Aucune personne ni entité ne les contrôle, et il est pratiquement impossible de les censurer. Elles peuvent contrôler des actifs numériques afin de créer de nouveaux types d'applications.
+Utilisez Ethereum pour créer des applications décentralisées (ou « dApps »). Ces dApps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Étant décentralisées, elles fonctionnent sur un réseau P2P et il n'existe aucun point de défaillance. Aucune personne ni entité ne les contrôle, et il est pratiquement impossible de les censurer. Elles peuvent contrôler des actifs numériques afin de créer de nouveaux types d'applications.
## Premiers pas avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity}
@@ -16,8 +16,8 @@ Utilisez Ethereum pour créer des applications décentralisées (ou « dApps »)
Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/).
- [Explication de la blockchain](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
-- [Comprendre les contrats autonomes](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
-- [Écrire votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [Comprendre les contrats intelligents](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [Écrivez votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
- [Apprendre à compiler et à déployer avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
- [Tutoriel de contrat](https://github.com/ethereum/go-ethereum/wiki/Contract-Tutorial)
@@ -33,11 +33,11 @@ Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/le
## Articles et documentation de niveau intermédiaire {#intermediate-articles-and-docs}
- [Documentation Go Ethereum](https://geth.ethereum.org/docs/) - _Documentation Ethereum officielle pour Go_
-- [Guide du programmeur Ergion](https://github.com/ledgerwatch/ergion/blob/devel/docs/programmers_guide/guide.md) - _Guide illustré incluant l'arborescence d'état, les multipreuves et le traitement des transactions_
-- [Erigon et Ethereum sans état](https://youtu.be/3-Mn7OckSus?t=394) - _Conférence de la communauté Ethereum 2020 (EthCC 3)_
-- [Erigon: optimiser les clients Ethereum](https://www.youtube.com/watch?v=CSpc1vZQW2Q) - _Devcon 4 - 2018 _
+- [Guide du programmeur Erigon](https://github.com/ledgerwatch/erigon/blob/devel/docs/programmers_guide/guide.md) - _Guide illustré incluant l'arborescence d'état, les multipreuves et le traitement des transactions_
+- [Erigon et Ethereum sans état](https://youtu.be/3-Mn7OckSus?t=394) - _Conférence de la Communauté Ethereum 2020 (EthCC 3)_
+- [Erigon : optimiser les clients Ethereum](https://www.youtube.com/watch?v=CSpc1vZQW2Q) - _2018 Devcon 4_
- [GoDoc Go Ethereum](https://godoc.org/github.com/ethereum/go-ethereum)
-- [Créer un dApp avec Geth dans Go](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/creating-a-dapp-in-go-with-geth/)
+- [Créer une dApp avec Geth dans Go](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/creating-a-dapp-in-go-with-geth/)
- [Travailler avec le réseau privé Ethereum avec Golang et Geth](https://myhsts.org/tutorial-learn-how-to-work-with-ethereum-private-network-with-golang-with-geth.php)
- [Test unitaire des contrats Solidity avec Go dans Ethereum](https://medium.com/coinmonks/unit-testing-solidity-contracts-on-ethereum-with-go-3cc924091281)
- [Référence rapide pour utiliser Geth en tant que bibliothèque](https://medium.com/coinmonks/web3-go-part-1-31c68c68e20e)
@@ -54,16 +54,17 @@ Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/le
- [Geth/Go Ethereum](https://github.com/ethereum/go-ethereum) - _Implémentation officielle du protocole Ethereum_
- [Go Ethereum Code Analysis](https://github.com/ZtesoftCS/go-ethereum-code-analysis) - _Revue et analyse du code source Go Ethereum_
-- [Erigon](https://github.com/ledgerwatch/erigon) - _Dérivé plus rapide de Go Ethereum_
+- [Erigon](https://github.com/ledgerwatch/erigon) - _Dérivé plus rapide de Go Ethereum, focalisé sur les nœuds d'archives_
- [Golem](https://github.com/golemfactory/golem) - _Golem crée un marché mondial de distribution de puissance informatique_
- [Quorum](https://github.com/jpmorganchase/quorum) - _Implémentation d'Ethereum soumise à droit d'accès, prenant en charge la confidentialité des données_
-- [Prysm](https://github.com/prysmaticlabs/prysm) - _Implémentation d'Ethereum « Serenity » 2.0 Go _
+- [Prysm](https://github.com/prysmaticlabs/prysm) - _Implémentation d'Ethereum « Serenity » 2.0 Go_
- [Eth Tweet](https://github.com/yep/eth-tweet) - _Twitter décentralisé : service de microblogging fonctionnant sur la blockchain Ethereum_
- [Plasma MVP Golang](https://github.com/kyokan/plasma) - _Implémentation et extension Golang de la spécification Minimum Viable Plasma_
- [Open Ethereum Mining Pool](https://github.com/sammy007/open-ethereum-pool) - _Groupe de minage Ethereum en open source_
- [Ethereum HD Wallet](https://github.com/miguelmota/go-ethereum-hdwallet) - _Dérivations de portefeuilles HD (Hierarchical Deterministic, ou déterministe hiérarchique) Ethereum en Go_
- [Multi Geth](https://github.com/multi-geth/multi-geth) - _Support pour de nombreux types de réseaux Ethereum_
- [Geth Light Client](https://github.com/zsfelfoldi/go-ethereum/wiki/Geth-Light-Client) - _Implémentation Geth du LES (Light Client Subprotocol) Ethereum_
+- [Ethereum Golang SDK](https://github.com/everFinance/goether) - _Une simple implémentation et des utilitaires pour les portefeuilles Ethereum dans Golang_
Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers.](/developers/)
diff --git a/src/content/translations/fr/developers/docs/programming-languages/java/index.md b/src/content/translations/fr/developers/docs/programming-languages/java/index.md
index eaa9a0444c8..eedf0751121 100644
--- a/src/content/translations/fr/developers/docs/programming-languages/java/index.md
+++ b/src/content/translations/fr/developers/docs/programming-languages/java/index.md
@@ -1,13 +1,13 @@
---
title: Ethereum pour les développeurs Java
-description: Apprendre à développer sur Ethereum avec des projets et des outils basés sur Java
+description: Apprendre à développer pour Ethereum avec des projets et des outils basés sur Java
lang: fr
incomplete: true
---
Apprendre à développer pour Ethereum avec des projets et des outils basés sur Java
-Utilisez Ethereum pour créer des applications décentralisées (ou « dapps ») qui bénéficient des avantages des crypto-monnaies et de la technologie blockchain. Ces dapps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune entité ou personne ne les contrôle et qu'il est pratiquement impossible de les censurer.
+Utilisez Ethereum pour créer des applications décentralisées (ou "DApps") qui tirent parti de la technologie de la blockchain et des cryptomonnaies. Ces DApps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune personne ni entité ne les contrôle et qu'il est pratiquement impossible de les censurer.
## Premiers pas avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity}
@@ -16,7 +16,7 @@ Utilisez Ethereum pour créer des applications décentralisées (ou « dapp
Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/)
- [Explication de la blockchain](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
-- [Comprendre les contrats autonomes](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [Comprendre les contrats intelligents](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
- [Écrire votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
- [Apprendre à compiler et à déployer avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
@@ -33,7 +33,7 @@ Apprenez à utiliser [Web3J](https://github.com/web3j/web3j) et Hyperledger Besu
- [Exécuter un nœud Hyperledger Besu (Pantheon) dans les tests d'intégration Java](https://kauri.io/article/7dc3ecc391e54f7b8cbf4e5fa0caf780/running-a-pantheon-node-in-java-integration-tests)
- [Mémo Web3j]()
-## Articles de niveau intermédiaire {#intermediate-articles}
+## Articles intermédiaires {#intermediate-articles}
- [Gestion du stockage avec IPFS dans une application Java](https://kauri.io/article/3e8494f4f56f48c4bb77f1f925c6d926/managing-storage-in-a-java-application-with-ipfs)
- [Gestion des jetons ERC20 avec Web3j dans Java](https://kauri.io/article/d13e911bbf624108b1d5718175a5e0a0/manage-erc20-tokens-in-java-with-web3j)
diff --git a/src/content/translations/fr/developers/docs/programming-languages/javascript/index.md b/src/content/translations/fr/developers/docs/programming-languages/javascript/index.md
index 453c23c241f..4be48af284b 100644
--- a/src/content/translations/fr/developers/docs/programming-languages/javascript/index.md
+++ b/src/content/translations/fr/developers/docs/programming-languages/javascript/index.md
@@ -63,7 +63,7 @@ Plein d'autres choses voient le jour au pays d'Ethereum JavaScript, y compris :
- des outils pour générer, importer et exporter des clés Ethereum ;
- une implémentation du `merkle-patricia-tree`, une structure de données décrite dans le Livre jaune Ethereum.
-Explorez ce qui vous intéresse le plus dans [EthereumJS](https://github.com/ethereumjs).
+Explorez ce qui vous intéresse le plus dans le répertoire[EthereumJS](https://github.com/ethereumjs).
## Complément d'information {#further-reading}
diff --git a/src/content/translations/fr/developers/docs/programming-languages/python/index.md b/src/content/translations/fr/developers/docs/programming-languages/python/index.md
index 570e93c1114..859c0d6fc50 100644
--- a/src/content/translations/fr/developers/docs/programming-languages/python/index.md
+++ b/src/content/translations/fr/developers/docs/programming-languages/python/index.md
@@ -1,13 +1,13 @@
---
title: Ethereum pour les développeurs Python
-description: Apprendre à développer sur Ethereum avec des projets et des outils basés sur Python
+description: Apprendre à développer pour Ethereum avec des projets et des outils basés sur Python
lang: fr
incomplete: true
---
Apprendre à développer pour Ethereum avec des projets et des outils basés sur Python
-Utilisez Ethereum pour créer des applications décentralisées (ou « dapps ») qui bénéficient des avantages des crypto-monnaies et de la technologie blockchain. Ces dapps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune entité ou personne ne les contrôle et qu'il est pratiquement impossible de les censurer.
+Utilisez Ethereum pour créer des applications décentralisées (ou « dApps ») qui tirent parti de la technologie de la blockchain et des cryptomonnaies. Ces DApps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune personne ni entité ne les contrôle et qu'il est pratiquement impossible de les censurer.
## Premiers pas avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity}
@@ -16,20 +16,21 @@ Utilisez Ethereum pour créer des applications décentralisées (ou « dapp
Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/).
- [Explication de la blockchain](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
-- [Comprendre les contrats autonomes](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [Comprendre les contrats intelligents](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
- [Écrire votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [Apprendre à compiler et à déployer avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [Apprendre à compiler et à déployer une application avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
## Articles pour les débutants {#beginner-articles}
- [Guide du développeur (Python) pour Ethereum](https://snakecharmers.ethereum.org/a-developers-guide-to-ethereum-pt-1/)
-- [Introduction aux contrats intelligents avec Vyper](https://kauri.io/#collections/Getting%20Started/an-introduction-to-smart-contracts-with-vyper/)
+- [Rapport sur l'état de Python dans la blockchain 2023](https://tradingstrategy.ai/blog/the-state-of-python-in-blockchain-in-2023)
+- [An Introduction to Smart Contracts with Vyper](https://kauri.io/#collections/Getting%20Started/an-introduction-to-smart-contracts-with-vyper/)
- [Déployez votre propre jeton ERC20 avec Python et Brownie](https://betterprogramming.pub/python-blockchain-token-deployment-tutorial-create-an-erc20-77a5fd2e1a58)
-- [Comment développer un contrat Ethereum avec Python Flask ?](https://medium.com/coinmonks/how-to-develop-ethereum-contract-using-python-flask-9758fe65976e)
-- [Intro à Web3.py · Ethereum pour les développeurs Python](https://www.dappuniversity.com/articles/web3-py-intro)
-- [Comment appeler une fonction du contrat intelligent en utilisant Python et web3.py](https://stackoverflow.com/questions/57580702/how-to-call-a-smart-contract-function-using-python-and-web3-py)
+- [How to develop Ethereum contract using Python Flask?](https://medium.com/coinmonks/how-to-develop-ethereum-contract-using-python-flask-9758fe65976e)
+- [Intro to Web3.py · Ethereum For Python Developers](https://www.dappuniversity.com/articles/web3-py-intro)
+- [How to call a Smart Contract function using Python and web3.py](https://stackoverflow.com/questions/57580702/how-to-call-a-smart-contract-function-using-python-and-web3-py)
-## Articles de niveau intermédiaire {#intermediate-articles}
+## Articles intermédiaires {#intermediate-articles}
- [Développement de dApp pour programmeurs Python](https://levelup.gitconnected.com/dapps-development-for-python-developers-f52b32b54f28)
- [Création d'une interface Python Ethereum : 1ère partie](https://hackernoon.com/creating-a-python-ethereum-interface-part-1-4d2e47ea0f4d)
@@ -48,9 +49,9 @@ Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/le
### Actifs : {#active}
- [Web3.py](https://github.com/ethereum/web3.py) - _Bibliothèque Python pour interagir avec Ethereum_
-- [Singe](https://github.com/ApeWorX/ape) - _L'outil de développement de contrats intelligents pour pythonistes, les data scientists et les professionnels de la sécurité_
-- [Brownie](https://github.com/eth-brownie/brownie) - _Infrastructure Python pour déployer et tester les contrats intelligents Ethereum, et interagir avec ces derniers_
- [Vyper](https://github.com/ethereum/vyper/) - _Langage des contrats intelligents en Python pour l'EVM_
+- [Ape](https://github.com/ApeWorX/ape) - _L'outil de développement de contrats intelligents pour les pythonistes, les data scientists et les professionnels de la sécurité_
+- [Brownie](https://github.com/eth-brownie/brownie) - _Infrastructure Python pour déployer et tester les contrats intelligents Ethereum, et interagir avec ces derniers_
- [py-evm](https://github.com/ethereum/py-evm) - _Implémentation de la machine virtuelle Ethereum_
- [eth-tester](https://github.com/ethereum/eth-tester) - _Outils pour tester des applications basées sur Ethereum_
- [eth-utils](https://github.com/ethereum/eth-utils/) - _Fonctions utilitaires pour travailler avec les bases de code liées à Ethereum_
@@ -59,7 +60,7 @@ Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/le
- [pydevp2p](https://github.com/ethereum/pydevp2p) - _Implémentation de la pile P2P Ethereum_
- [pymaker](https://github.com/makerdao/pymaker) - _API Python pour les contrats Maker_
- [siwe](https://github.com/spruceid/siwe-py) - _Connectez-vous avec Ethereum (siwe) pour Python_
-- [Contrats intelligents pour les tests](https://github.com/tradingstrategy-ai/smart-contracts-for-testing) - _Un paquet Python livré avec ERC-20, Uniswap et d'autres contrats courants pour l'écriture de tests avec Web3.py_
+- [Intégration Web3 DeFi pour Ethereum](https://github.com/tradingstrategy-ai/web3-ethereum-defi) - _Un paquet Python avec des intégrations prêtes à l'emploi pour ERC-20, Uniswap et d'autres projets populaires_
### Archivé / Non entretenu : {#archived--no-longer-maintained}
@@ -78,9 +79,10 @@ Les projets Ethereum suivants utilisent les outils mentionnés sur cette page. L
- [Sushi](https://sushi.com/) utilise [Python pour gérer et déployer leurs contrats d'acquisition](https://github.com/sushiswap/sushi-vesting-protocols)
- [Alpha Finance](https://alphafinance.io/), de la célèbre Alpha Homora, utilise [Brownie pour tester et déployer des contrats intelligents](https://github.com/AlphaFinanceLab/alpha-staking-contract)
-## Contributeurs de la communauté Python {#python-community-contributors}
+## Discussion de la Communauté Python {#python-community-contributors}
-La communauté [Ethereum Python Discord](https://discord.gg/9zk7snTfWe) est l'hôte d'une communauté en pleine croissance et est la ressource dédiée pour discuter de l'un des projets ci-dessus et d'autres sujets connexes.
+- [Discord de la Communauté Python Ethereum](https://discord.gg/9zk7snTfWe) pour la discussion sur Web3.py et autre framework Python
+- [Vyper Discord](<[https://discord.gg/9zk7snTfWe](https://discord.gg/SdvKC79cJk)>) pour les discussions concernant la programmation avec Vyper des contrats intelligents
## Autres ressources {#other-aggregated-lists}
diff --git a/src/content/translations/fr/developers/docs/programming-languages/ruby/index.md b/src/content/translations/fr/developers/docs/programming-languages/ruby/index.md
index d4404969f00..ff0a46d30b3 100644
--- a/src/content/translations/fr/developers/docs/programming-languages/ruby/index.md
+++ b/src/content/translations/fr/developers/docs/programming-languages/ruby/index.md
@@ -7,20 +7,20 @@ incomplete: false
Apprendre à développer sur Ethereum en utilisant des projets et des outils basés sur Ruby.
-Utilisez Ethereum pour créer des applications décentralisées (ou « dapps ») qui bénéficient des avantages des crypto-monnaies et de la technologie blockchain. Ces dApps sont dignes de confiance, c'est-à-dire qu'une fois déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune entité ou personne ne les contrôle et qu'il est pratiquement impossible de les censurer.
+Utilisez Ethereum pour créer des applications décentralisées (ou « dApps ») qui tirent parti de la technologie de la blockchain et des cryptomonnaies. Ces dApps sont dignes de confiance, c'est-à-dire qu'une fois déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune personne ni entité ne les contrôle et qu'il est pratiquement impossible de les censurer.
-## Premiers pas avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity}
+## Débuter avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity}
**Commencer à intégrer Ruby avec Ethereum**
Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/).
- [Explication de la blockchain](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
-- [Comprendre les contrats autonomes](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [Comprendre les contrats intelligents](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
- [Écrire votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [Apprendre à compiler et à déployer avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [Apprendre à compiler et à déployer Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
-## Articles pour les débutants {#beginner-articles}
+## Articles pour débutants {#beginner-articles}
- [Bien comprendre les comptes Ethereum](https://dev.to/q9/finally-understanding-ethereum-accounts-1kpe)
- [Authentifier les utilisateurs Rails avec MetaMask](https://dev.to/q9/finally-authenticating-rails-users-with-metamask-3fj)
diff --git a/src/content/translations/fr/developers/docs/programming-languages/rust/index.md b/src/content/translations/fr/developers/docs/programming-languages/rust/index.md
index 9390f315625..8f534bfadad 100644
--- a/src/content/translations/fr/developers/docs/programming-languages/rust/index.md
+++ b/src/content/translations/fr/developers/docs/programming-languages/rust/index.md
@@ -1,13 +1,13 @@
---
title: Ethereum pour les développeurs Rust
-description: Apprendre à développer sur Ethereum avec des projets et des outils basés sur Rust
+description: Apprendre à développer pour Ethereum avec des projets et des outils basés sur Rust
lang: fr
incomplete: true
---
Apprendre à développer pour Ethereum avec des projets et des outils basés sur Rust
-Utilisez Ethereum pour créer des applications décentralisées (ou « dapps ») qui bénéficient des avantages des crypto-monnaies et de la technologie blockchain. Ces dapps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune entité ou personne ne les contrôle et qu'il est pratiquement impossible de les censurer.
+Utilisez Ethereum pour créer des applications décentralisées (ou « dApps ») qui tirent parti de la technologie de la blockchain et des cryptomonnaies. Ces dApps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune personne ni entité ne les contrôle et qu'il est pratiquement impossible de les censurer.
## Premiers pas avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity}
@@ -16,7 +16,7 @@ Utilisez Ethereum pour créer des applications décentralisées (ou « dapp
Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/).
- [Explication de la blockchain](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
-- [Comprendre les contrats autonomes](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [Comprendre les contrats intelligents](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
- [Écrire votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
- [Apprendre à compiler et à déployer avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
@@ -28,35 +28,36 @@ Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/le
- [Une introduction aux contrats intelligents avec le client Ethereum Parity](https://wiki.parity.io/Smart-Contracts)
- [Un tutoriel sur la façon d'écrire des contrats dans Rust Wasm pour Kovan](https://github.com/paritytech/pwasm-tutorial)
-## Articles de niveau intermédiaire {#intermediate-articles}
+## Articles intermédiaires {#intermediate-articles}
## Modèles d'utilisation avancés {#advanced-use-patterns}
-- [bibliothèque externe pwasm_ethereum pour interagir avec un réseau de type Ethereum](https://github.com/openethereum/pwasm-ethereum)
-- [Construire un chat décentralisé en utilisant JavaScript et Rust](https://medium.com/perlin-network/build-a-decentralized-chat-using-javascript-rust-webassembly-c775f8484b52)
-- [Construire une application Todo décentralisée en utilisant Vue.js et Rust](https://medium.com/@jjmace01/build-a-decentralized-todo-app-using-vue-js-rust-webassembly-5381a1895beb)
-- [Commencer avec Enigma : avec le langage de programmation Rust](https://blog.enigma.co/getting-started-with-discovery-the-rust-programming-language-4d1e0b06de15)
-- [Introduction aux contrats secrets](https://blog.enigma.co/getting-started-with-enigma-an-intro-to-secret-contracts-cdba4fe501c2)
+- [pwasm_ethereum externs library to interact with Ethereum-like network](https://github.com/openethereum/pwasm-ethereum)
+- [Build A Decentralized Chat Using JavaScript and Rust](https://medium.com/perlin-network/build-a-decentralized-chat-using-javascript-rust-webassembly-c775f8484b52)
+- [Build a Decentralized Todo App Using Vue.js & Rust](https://medium.com/@jjmace01/build-a-decentralized-todo-app-using-vue-js-rust-webassembly-5381a1895beb)
+
+- [An Intro to Secret Contracts](https://blog.enigma.co/getting-started-with-enigma-an-intro-to-secret-contracts-cdba4fe501c2)
+- [Construire une blockchain en Rust](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/)
## Projets et outils Rust {#rust-projects-and-tools}
- [pwasm-ethereum](https://github.com/paritytech/pwasm-ethereum) - _Collection d'éléments externes pour interagir avec un réseau de type Ethereum_
- [Lighthouse](https://github.com/sigp/lighthouse) - _Client rapide de la couche de consensus d'Ethereum_
-- [Assemblée web d'Ethereum](https://ewasm.readthedocs.io/en/mkdocs/)
+- [Ethereum WebAssembly](https://ewasm.readthedocs.io/en/mkdocs/) - _Proposition de refonte de la couche d'exécution des contrats intelligents d'Ethereum en utilisant un sous-ensemble déterministe de WebAssembly_
- [oasis_std](https://docs.rs/oasis-std/0.2.7/oasis_std/) - _Référence de l'API OASIS_
-- [Solaris](https://github.com/paritytech/sol-rs)
-- [SputnikVM](https://github.com/sorpaas/rust-evm) - _Implémentation en Rust de machines virtuelles Ethereum_
-- [Wavelet](https://wavelet.perlin.net/docs/smart-contracts) - _Contrats intelligents Wavelet en Rust_
+- [Solaris](https://github.com/paritytech/sol-rs) - _Exploiter le test unitaire des contrats intelligents Solidity utilisant l'EVM natif du client Parity._
+- [SputnikVM](https://github.com/rust-blockchain/evm) - _Implémentation en Rust de machines virtuelles Ethereum_
+- [Wavelet](https://wavelet.perlin.net/docs/smart-contracts) - _Contrats intelligents Wavelet sous Rust_
- [Foundry](https://github.com/gakonst/foundry)- _Boîte à outils pour le développement d'applications Ethereum_
- [Ethers_rs](https://github.com/gakonst/ethers-rs) - _Bibliothèque Ethereum et implémentation de portefeuille_
-- [evm_rs](https://github.com/rust-blockchain/evm) - _Implémentation de la machine virtuelle Ethereum en Rust_
- [SewUp](https://github.com/second-state/SewUp) - _Bibliothèque pour vous aider aussi bien à créer votre contrat Webassembly Ethereum avec Rust que développer un backend commun._
+- [Reth](https://github.com/paradigmxyz/reth) Reth (sous le nom de Rust Ethereum, en abrégé Reth, prononciation) : il s'agit d'une nouvelle implémentation de nœud complet sur Ethereum
Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers.](/developers/)
## Contributeurs de la communauté Rust {#rust-community-contributors}
-- [WebAssembly Ethereum](https://gitter.im/ewasm/Lobby)
+- [Ethereum WebAssembly](https://gitter.im/ewasm/Lobby)
- [Gitter d'Oasis](https://gitter.im/Oasis-official/Lobby)
- [Gitter de Parity](https://gitter.im/paritytech/parity)
- [Enigma](https://discord.gg/SJK32GY)
diff --git a/src/content/translations/fr/developers/docs/smart-contracts/anatomy/index.md b/src/content/translations/fr/developers/docs/smart-contracts/anatomy/index.md
index 2e5a122f0dc..e9864f02465 100644
--- a/src/content/translations/fr/developers/docs/smart-contracts/anatomy/index.md
+++ b/src/content/translations/fr/developers/docs/smart-contracts/anatomy/index.md
@@ -639,7 +639,7 @@ contract CryptoPizza is IERC721, ERC165 {
}
```
-## En lire plus {#further-reading}
+## Complément d'information {#further-reading}
Consultez la documentation Solidity et Vyper pour une vue d'ensemble plus complète des contrats intelligents :
diff --git a/src/content/translations/fr/developers/docs/smart-contracts/compiling/index.md b/src/content/translations/fr/developers/docs/smart-contracts/compiling/index.md
index fc9d2c5cfd2..a5dcb5fedda 100644
--- a/src/content/translations/fr/developers/docs/smart-contracts/compiling/index.md
+++ b/src/content/translations/fr/developers/docs/smart-contracts/compiling/index.md
@@ -1,5 +1,5 @@
---
-title: Compiler des contrats intelligents
+title: Compiler des contrat intelligents
description: Explication de la raison d'une compilation et pourquoi elle est nécessaire pour les contrats intelligents
lang: fr
incomplete: true
@@ -275,4 +275,4 @@ Vous trouverez ci-dessous l’ABI pour le contrat de jetons ERC-20. Un jeton ERC
## Sujets connexes {#related-topics}
- [Bibliothèques clientes JavaScript](/developers/docs/apis/javascript/)
-- [Machine virtuelle Ethereum (EVM)](/developers/docs/ethereum-virtual-machine/)
+- [Machine virtuelle Ethereum (EVM)](/developers/docs/evm/)
diff --git a/src/content/translations/fr/developers/docs/smart-contracts/deploying/index.md b/src/content/translations/fr/developers/docs/smart-contracts/deploying/index.md
index dadd66c6714..aee467780a8 100644
--- a/src/content/translations/fr/developers/docs/smart-contracts/deploying/index.md
+++ b/src/content/translations/fr/developers/docs/smart-contracts/deploying/index.md
@@ -1,5 +1,5 @@
---
-title: Déployer des contrats intelligents
+title: Déployer des contrat intelligents
description:
lang: fr
---
@@ -12,7 +12,7 @@ Déployer un contrat intelligent consiste à envoyer sur la blockchain une trans
Il est préférable d'avoir compris en quoi consiste les [réseaux Ethereum](/developers/docs/networks/), les [transactions](/developers/docs/transactions/) et l'[anatomie des contrats intelligents](/developers/docs/smart-contracts/anatomy/) avant de déployer des contrats intelligents.
-Le déploiement d'un contrat coûte également des ethers, nous vous recommandons donc de vous familiariser avec le [gaz et les frais](/developers/docs/gas/) sur Ethereum.
+Le déploiement d'un contrat coûte également de l'éther (ETH) puisqu'il est stocké sur la blockchain, vous devez donc être familiarisé avec [le gaz et les frais](/developers/docs/gas/) sur Ethereum.
Enfin, comme vous devrez compiler votre contrat avant de le déployer, assurez-vous d'avoir lu la page sur la [compilation des contrats intelligents](/developers/docs/smart-contracts/compiling/).
@@ -23,7 +23,7 @@ Enfin, comme vous devrez compiler votre contrat avant de le déployer, assurez-v
- Le bytecode du contrat, généré par la [compilation](/developers/docs/smart-contracts/compiling/).
- Des ethers pour le gaz. Vous fixerez votre limite de gaz comme pour les autres transactions, mais sachez que les déploiements de contrats nécessitent beaucoup plus de gaz qu'un simple transfert d'ethers.
- Un script de déploiement ou un plugin.
-- l'accès à un [nœud Ethereum](/developers/docs/nodes-and-clients/), soit en créant le vôtre, soit en vous connectant à un nœud public, soit via un [service de nœuds](/developers/docs/nodes-and-clients/nodes-as-a-service/) comme Infura ou Alchemy avec une clé d'API
+- l'accès à un [nœud Ethereum](/developers/docs/nodes-and-clients/), soit en créant le vôtre, soit en vous connectant à un nœud public, soit via un [service de nœuds](/developers/docs/nodes-and-clients/nodes-as-a-service/) avec une clé d'API
### Étapes pour déployer un contrat intelligent {#steps-to-deploy}
@@ -37,7 +37,7 @@ Une fois déployé, votre contrat aura une adresse Ethereum comme les autres [co
- [Remix](https://remix.ethereum.org)
-**Tenderly - _Simuler, déboguer et surveiller quoi que ce soit sur des chaînes compatibles EVM, avec des données en temps réel_**
+**Tenderly - _ - Plateforme de développement Web3 qui fournit des blocs de débogage, d'observabilité et de construction d'infrastructures en vue de l'élaboration, de la mise à l'essai, du suivi et de l'exécution de contrats intelligents_**
- [tenderly.co](https://tenderly.co/)
- [Documentation](https://docs.tenderly.co/)
@@ -60,8 +60,9 @@ Une fois déployé, votre contrat aura une adresse Ethereum comme les autres [co
## Tutoriels connexes {#related-tutorials}
- [Déployer votre premier contrat intelligent](/developers/tutorials/deploying-your-first-smart-contract/) _– Introduction au déploiement de votre premier contrat intelligent sur un réseau de test Ethereum_
+- [Hello World | Un tutoriel sur le contrat intelligent](/developers/tutorials/hello-world-smart-contract/) _– Un tutoriel facile à suivre pour créer, & déployer un contrat intelligent de base sur Ethereum._
- [Interagir avec d'autres contrats Solidity](/developers/tutorials/interact-with-other-contracts-from-solidity/) _- Comment déployer et interagir avec un contrat intelligent à partir d'un contrat existant_
-- [Réduire les contrats pour respecter la limite de taille](/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/) _- Comment réduire la taille de votre contrat pour le garder sous la limite et économiser du gaz_
+- [Comment réduire la taille de votre contrat](/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/) _- Comment réduire la taille de votre contrat pour le garder sous la limite et économiser du gaz_
## Complément d'information {#further-reading}
@@ -74,3 +75,4 @@ _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
- [Infrastructures de développement](/developers/docs/frameworks/)
- [Exécuter un nœud Ethereum](/developers/docs/nodes-and-clients/run-a-node/)
+- [Nœuds en tant que service](/developers/docs/nodes-and-clients/nodes-as-a-service)
diff --git a/src/content/translations/fr/developers/docs/smart-contracts/index.md b/src/content/translations/fr/developers/docs/smart-contracts/index.md
index 35bf966dc02..ac87a89bb8b 100644
--- a/src/content/translations/fr/developers/docs/smart-contracts/index.md
+++ b/src/content/translations/fr/developers/docs/smart-contracts/index.md
@@ -8,9 +8,9 @@ lang: fr
Un "contrat intelligent" est simplement un programme exécuté sur la blockchain d'Ethereum. C'est un ensemble de code (ses fonctions) et de données (son état) qui réside à une adresse spécifique sur la blockchain Ethereum.
-Le contrat intelligent est un type de [compte Ethereum](/developers/docs/accounts/). Cela signifie qu'il dispose d'un solde et peut envoyer des transactions sur le réseau. Cependant, il n'est pas contrôlé par un utilisateur, mais est plutôt déployé et exécuté comme un programme. Les comptes des utilisateurs peuvent ensuite interagir avec un contrat intelligent en soumettant des transactions qui exécutent une fonction définie sur le contrat intelligent. Un contrat intelligent peut définir des règles, comme un contrat normal, et les appliquer automatiquement via le code. Les contrats intelligents ne peuvent pas être supprimés par défaut et les interactions avec eux sont irréversibles.
+Le contrat intelligent est un type de [compte Ethereum](/developers/docs/accounts/). Ceci veut dire qu'ils ont un solde et peuvent être la cible de transactions. Cependant, il n'est pas contrôlé par un utilisateur, mais est plutôt déployé et exécuté comme un programme. Les comptes des utilisateurs peuvent ensuite interagir avec un contrat intelligent en soumettant des transactions qui exécutent une fonction définie sur le contrat intelligent. Un contrat intelligent peut définir des règles, comme un contrat normal, et les appliquer automatiquement via le code. Les contrats intelligents ne peuvent pas être supprimés par défaut et les interactions avec eux sont irréversibles.
-## Pré-requis {#prerequisites}
+## Prérequis {#prerequisites}
Si vous venez tout juste de débuter ou si vous cherchez une introduction moins technique, nous vous recommandons notre [introduction aux contrats intelligents](/smart-contracts/).
@@ -28,7 +28,7 @@ money + snack selection = snack dispensed
Cette logique est programmée dans les distributeurs automatiques.
-Le contrat intelligent, comme un distributeur automatique, possède une logique programmée. Voici un exemple simple de la façon dont ce distributeur automatique pourrait ressembler à un contrat intelligent :
+Le contrat intelligent, comme un distributeur automatique, possède une logique programmée. Voici un exemple simple de ce à quoi ce distributeur automatique pourrait ressembler s'il était un contrat intelligent rédigé avec Solidity :
```solidity
pragma solidity 0.8.7;
@@ -67,7 +67,7 @@ Tout comme un distributeur automatique peut remplacer un employé dans une bouti
## Sans autorisation {#permissionless}
-N'importe qui peut rédiger un contrat intelligent et le déployer sur le réseau. Il vous suffit d'apprendre à coder dans un [langage de contrat intelligent](/developers/docs/smart-contracts/languages/) et de disposer de suffisamment d'ETH pour déployer votre contrat. Techniquement, le fait de déployer un contrat intelligent constitue une transaction. Vous devez donc payer pour le [carburant](/developers/docs/gas/), comme vous le feriez pour un simple transfert d'ETH. Les coûts en gaz requis pour déployer un contrat sont cependant beaucoup plus élevés.
+N'importe qui peut rédiger un contrat intelligent et le déployer sur le réseau. Il vous suffit d'apprendre à coder dans un [langage de contrat intelligent](/developers/docs/smart-contracts/languages/) et de disposer de suffisamment d'ETH pour déployer votre contrat. Techniquement, le fait de déployer un contrat intelligent est une transaction. L'auteur doit donc payer des frais de [Gaz](/developers/docs/gas/) de la même façon qu'il s'acquitterait de ces frais pour un simple transfert d'ETH. Toutefois, les frais de gaz pour le déploiement d'un contrat sont beaucoup plus élevés.
Pour la rédaction des contrats intelligents, Ethereum propose aux développeurs des langages conviviaux :
@@ -80,7 +80,7 @@ Toutefois, pour que la machine virtuelle Ethereum puisse interpréter et stocker
## Composabilité {#composability}
-Sur Ethereum, les contrats intelligents sont publics. Ils peuvent être considérés comme des API ouvertes. Cela signifie que vous pouvez appeler d'autres contrats intelligents dans votre propre contrat afin d'étendre considérablement les possibilités. Certains d'entre eux peuvent même déployer d'autres contrats.
+Sur Ethereum, les contrats intelligents sont publics. Ils peuvent être considérés comme des API ouvertes. Cela signifie que vous pouvez appeler d'autres contrats intelligents dans votre propre contrat afin d'en étendre considérablement les fonctionnalités. Certains d'entre eux peuvent même déployer d'autres contrats.
En savoir plus sur la [composabilité des contrats intelligents](/developers/docs/smart-contracts/composability/).
@@ -92,9 +92,13 @@ Il existe des moyens de contourner le problème en utilisant [oracles](/develope
Une autre limitation des contrats intelligents est la taille maximale des contrats. Un contrat intelligent ne peut pas dépasser 24 Ko, sans quoi il sera à court de gaz. Ceci peut être contourné en utilisant [Le modèle du diamant](https://eips.ethereum.org/EIPS/eip-2535).
+## Contrats Multisig {#multisig}
+
+Les contrats multisig (signature multiple) sont des comptes de contrats intelligents nécessitant plusieurs signatures valides pour exécuter une transaction. C'est très utile afin d'éviter les points de défaillance unique pour les contrats contenant des montants conséquents d'ether ou autres tokens. Les signatures multiples partagent la responsabilité d'exécution du contact ainsi que la gestion des clés entre plusieurs parties et évite la perte d'une unique clé privée amenant à la perte irréversible des fonds. Pour ces raisons, les contrats multisig peuvent être utilisés pour la simple gouvernance d'une DAO. La signature multiple requiert N signatures parmi M signatures possibles (où N ≤ M, et M > 1) pour permettre l'exécution. `N = 3, M = 5` et `N = 4, M = 7` sont assez répandus. Une multi-signature 4/7 requiert quatre signatures valides sur les sept possibles. Cela signifie que les fonds restent récupérables même si trois signatures sont perdues. Dans ce cas, cela signifie également que la majorité des détenteurs de clés doivent accepter et signer pour que le contrat puisse être exécuté.
+
## Ressources de contrats intelligents {#smart-contract-resources}
-**Contrats OpenZeppelin -** **_Bibliothèque la plus populaire pour développer des contrats intelligents de façon sécurisée_**
+**Contrats OpenZeppelin -** **_Bibliothèque pour développer des contrats intelligents de façon sécurisée_**
- [openzeppelin.com/contracts/](https://openzeppelin.com/contracts/)
- [GitHub](https://github.com/OpenZeppelin/openzeppelin-contracts)
diff --git a/src/content/translations/fr/developers/docs/smart-contracts/languages/index.md b/src/content/translations/fr/developers/docs/smart-contracts/languages/index.md
index 7998c091cb5..8f8e1aba8f8 100644
--- a/src/content/translations/fr/developers/docs/smart-contracts/languages/index.md
+++ b/src/content/translations/fr/developers/docs/smart-contracts/languages/index.md
@@ -1,5 +1,5 @@
---
-title: Langages du contrat intelligent
+title: Les langages des contrats intelligents
description: "Présentation et comparaison des deux principaux langages de contrat intelligent : Solidity et Vyper"
lang: fr
---
@@ -88,13 +88,14 @@ Cet exemple devrait vous donner une idée de la syntaxe d'un contrat Solidity. P
- Langage de programmation pythonique
- Typage fort
- Code de compilation concis et compréhensible
-- A intentionnellement moins de fonctionnalités que Solidity dans le but de rendre les contrats plus sécurisés et plus faciles à auditer . Vyper ne prend pas en charge les éléments suivants :
+- Génération efficace du bytecode
+- A intentionnellement moins de fonctionnalités que Solidity dans le but de rendre les contrats plus sécurisés et plus faciles à auditer. Vyper ne prend pas en charge les éléments suivants :
- Modificateurs
- Héritage
- Assemblage en ligne
- Surcharge des fonctions
- Surcharge d’opérateur
- - Appels récurrent
+ - Appels récurrents
- Boucles infinies
- Points fixes binaires
@@ -103,11 +104,17 @@ Pour plus d'informations, [lisez cette page Vyper](https://vyper.readthedocs.io/
### Liens importants {#important-links-1}
- [Documentation](https://vyper.readthedocs.io)
-- [Vyper by Example](https://vyper.readthedocs.io/en/latest/vyper-by-example.html)
+- [Vyper par exemple](https://vyper.readthedocs.io/en/latest/vyper-by-example.html)
+- [Plus de Vyper par exemple](https://vyper-by-example.org/)
- [GitHub](https://github.com/vyperlang/vyper)
-- [Chatroom Gitter Vyper](https://gitter.im/vyperlang/community)
+- [Discussion Discord pour la Communauté Vyper](https://discord.gg/SdvKC79cJk)
- [Cheat Sheet](https://reference.auditless.com/cheatsheet)
-- [Mise à jour du 8 janvier 2020](https://blog.ethereum.org/2020/01/08/update-on-the-vyper-compiler)
+- [Cadres et outils de développement des Contrats intelligents pour Vyper](/developers/docs/programming-languages/python/)
+- [VyperPunk - apprendre à sécuriser et à pirater les contrats intelligents Vyper](https://github.com/SupremacyTeam/VyperPunk)
+- [VyperExamples - exemples de vulnérabilités Vyper](https://www.vyperexamples.com/reentrancy)
+- [Hub Vyper pour le développement](https://github.com/zcor/vyper-dev)
+- [Exemples des meilleurs contrats intelligents pour Vyper](https://github.com/pynchmeister/vyper-greatest-hits/tree/main/contracts)
+- [Des ressources géniales liées à Vyper](https://github.com/spadebuilders/awesome-vyper)
### Exemple {#example}
@@ -206,7 +213,7 @@ Si vous débutez avec Ethereum et que vous n'avez pas encore jamais codé avec d
- Langage intermédiaire pour Ethereum
- Prends en charge l'[EVM](/developers/docs/evm) et l'[Ewasm](https://github.com/ewasm), un assemblage Web au petit goût d'Ethereum conçu pour être un dénominateur commun utilisable sur les deux plateformes.
-- Excellente cible pour les phases d'optimisation de haut niveau qui peuvent bénéficier à la fois aux plateformes EVM et Ewasm.
+- Excellente cible pour les phases d'optimisation de haut niveau qui peuvent bénéficier à la fois aux plateformes EVM et eWASM.
**Yul+**
diff --git a/src/content/translations/fr/developers/docs/smart-contracts/security/index.md b/src/content/translations/fr/developers/docs/smart-contracts/security/index.md
index 4fcabef1895..287bd5892ef 100644
--- a/src/content/translations/fr/developers/docs/smart-contracts/security/index.md
+++ b/src/content/translations/fr/developers/docs/smart-contracts/security/index.md
@@ -1,148 +1,246 @@
---
title: Sécurité des contrats intelligents
-description: Considérations de sécurité pour les développeurs Ethereum
+description: Un aperçu des lignes directrices pour la construction de contrats intelligents sécurisés Ethereum
lang: fr
---
-Les contrats intelligents Ethereum sont extrêmement flexibles, capables à la fois de détenir de grandes quantités de jetons (souvent plus de 1 milliard de $) et d'exécuter une logique immuable sur du code intelligent précédemment déployé. Alors que cela a créé un écosystème dynamique et créatif de contrats intelligents interconnectés et trustless, c'est aussi l'écosystème parfait pour attirer les attaquants qui cherchent à en tirer profit en exploitant des vulnérabilités dans les contrats intelligents et des comportements inattendus dans Ethereum. Le code d'un contrat intelligent ne peut _habituellement_ pas être modifié pour corriger les défauts de sécurité, les actifs volés à partir de contrats intelligents sont irrécupérables et extrêmement difficiles à tracer. Le montant total des sommes volées ou perdues en raison de problèmes sur les contrats intelligents atteint facilement le milliard de dollars. Voici quelques-uns des problèmes les plus importants dus à des erreurs de codage de contrat intelligent :
+Les contrats intelligents sont extrêmement flexibles et capables de contrôler de grandes quantités de valeur et de données, tout en exécutant une logique immuable basée sur le code déployé sur la blockchain. Cela a créé un écosystème dynamique d’applications sans tiers de confiance et décentralisées qui offrent de nombreux avantages par rapport aux systèmes existants. Ils représentent également des opportunités pour les attaquants qui cherchent à tirer profit de vulnérabilités dans les contrats intelligents.
-- [Problème n°1 de multisig Parity - 30 millions de dollars perdus](https://www.coindesk.com/30-million-ether-reported-stolen-parity-wallet-breach)
-- [Problème n°2 de multisig Parity - 300 millions de dollars perdus](https://www.theguardian.com/technology/2017/nov/08/cryptocurrency-300m-dollars-stolen-bug-ether)
-- [Hack TheDAO, 3,6 millions d'ETH ! Prés de 1 milliard de dollars en prix actuel de l'ETH](https://hackingdistributed.com/2016/06/18/analysis-of-the-dao-exploit/)
+Les blockchains publiques, comme Ethereum, compliquent encore davantage la question de la sécurisation des contrats intelligents. Le code de contrat déployé ne peut _généralement_ pas être modifié pour corriger des défauts de sécurité, et les actifs volés sur des contrats intelligents sont extrêmement difficiles à suivre et la plupart du temps irrécupérables en raison de l’immuabilité.
+
+Bien que les chiffres varient, on estime que le montant total de la valeur volée ou perdue en raison de défauts de sécurité dans les contrats intelligents est d'au moins 1 milliard de dollars. Cela inclut des incidents de haut niveau, tels que [le hack de DAO](https://hackingdistributed.com/2016/06/18/analysis-of-the-dao-exploit/) (3,6 millions d'ETH volés, d'une valeur de plus de 1 milliard de dollars aux prix actuels), [le hack du portefeuille multi-sig Parity](https://www.coindesk.com/30-million-ether-reported-stolen-parity-wallet-breach) (30 millions de dollars volés par les hackeurs), et [le problème du portefeuille gelé Parity](https://www.theguardian.com/technology/2017/nov/08/cryptocurrency-300m-dollars-stolen-bug-ether) (plus de 300 millions de dollars en ETH verrouillés pour toujours).
+
+Les problèmes susmentionnés rendent impératif pour les développeurs d'investir des efforts dans la construction de contrats intelligents sécurisés, robustes et résistants. La sécurité des contrats intelligents est une affaire sérieuse, que chaque développeur ferait bien d’apprendre. Ce guide couvrira les considérations de sécurité des développeurs Ethereum et explorera les ressources pour améliorer la sécurité des contrats intelligents.
## Prérequis {#prerequisites}
-Cette page couvre la sécurité des contrats intelligents, donc assurez-vous d'être familiarisé avec les [contrats intelligents](/developers/docs/smart-contracts/) avant d'aborder la sécurité.
+Assurez-vous de vous familiariser avec les [fondamentaux du développement de contrats intelligent](/developers/docs/smart-contracts/) avant de vous attaquer à la sécurité.
-## Comment écrire un code de contrats intelligents plus sécurisé {#how-to-write-more-secure-smart-contract-code}
+## Lignes directrices pour la construction de contrats intelligents sécurisés Ethereum {#smart-contract-security-guidelines}
-Avant de lancer un code sur le réseau principal, il est important de prendre des précautions suffisantes pour protéger tout ce qui a de la valeur et qui est confié à votre contrat intelligent. Dans cet article, nous allons discuter de quelques attaques spécifiques, fournir des ressources pour en savoir plus sur les types d'attaques, et vous donner quelques outils et bonnes pratiques de base pour assurer le bon fonctionnement et la sécurité de vos contrats.
+### 1. Concevoir des contrôles d'accès appropriés {#design-proper-access-controls}
-## Les audits ne sont pas une solution miracle {#audits-are-not-a-silver-bullet}
+Dans les contrats intelligents, les fonctions marquées `publiques` ou `externes` peuvent être appelées par n'importe quel compte externe (EOA) ou compte de contrat. Il est nécessaire de spécifier une visibilité publique des fonctions si vous voulez que les autres interagissent avec votre contrat. Les fonctions marquées `privées` ne peuvent cependant être appelées que par des fonctions au sein du contrat intelligent, et non par des comptes externes. Donner à chaque participant au réseau un accès aux fonctions du contrat peut causer des problèmes, surtout si cela signifie que n'importe qui peut effectuer des opérations sensibles (par exemple, frapper de nouveaux jetons).
-Il y a des années, les outils permettant d'écrire, de compiler, de tester et de déployer des contrats intelligents manquaient de maturité, ce qui a généré de nombreux projets désordonnés d'écriture de code Solidity, code qui était ensuite transmis à un expert pour examen afin de s'assurer qu'il fonctionnait de façon sécurisée et comme prévu. En 2020, les processus de développement et les outils qui prennent en charge l'écriture de Solidity sont nettement meilleurs. En exploiter les bonnes pratiques permet non seulement de garantir que votre projet est plus facile à gérer, mais cela constitue un élément essentiel de sa sécurité. Un audit en fin de rédaction de votre contrat intelligent ne suffit plus comme seule considération de sécurité. La sécurité commence bien avant d'écrire votre première ligne de code de contrat intelligent, **elle commence par des processus de conception et de développement adéquats**.
+Pour éviter l'utilisation non autorisée de fonctions de contrats intelligents, il est nécessaire de mettre en place des contrôles d'accès sécurisés. Les mécanismes de contrôle d'accès restreignent la capacité d'utiliser certaines fonctions dans un contrat intelligent à des entités approuvées, comme les comptes responsables de la gestion du contrat. Le **modèle Ownable** et **le contrôle d'accès basé sur les rôles** sont deux pratiques utiles pour implémenter le contrôle d'accès dans les contrats intelligents :
-## Processus de développement de contrats intelligents {#smart-contract-development-process}
+#### Modèle Ownable {#ownable-pattern}
-Il faut au minimum que :
+Dans le modèle Ownable, une adresse est définie comme « propriétaire » du contrat au cours du processus de création du contrat. Les fonctions protégées sont assignées avec un modificateur `OnlyOwner` , qui assure que le contrat authentifie l'identité de l'adresse d'appel avant d'exécuter la fonction. Les appels à des fonctions protégées à partir d'autres adresses en dehors du propriétaire du contrat s'annulent toujours, empêchant l'accès non désiré.
-- tout le code soit stocké dans un système de contrôle de version comme git ;
-- toutes les modifications de code soient effectuées via des PR (Pull Requests) ;
-- toutes les PR aient au moins un réviseur ; _Si vous travaillez sur un projet en solo, envisagez de trouver un autre auteur solo pour négocier des révisions de code !_
-- une seule commande compile, déploie et exécute une suite de tests sur votre code en utilisant un environnement de développement Ethereum (Voir : Truffle) ;
-- vous ayez exécuté votre code via des outils d'analyse basiques comme Mythril et Slither, idéalement avant que chaque PR soit fusionnée, en comparant les différences de sortie ;
-- Solidity n'émette aucune alerte à la compilation ;
-- votre code soit bien documenté.
+#### Contrôle d'accès basé sur les rôles {#role-based-access-control}
-Il y a bien d'autres choses à dire sur les processus de développement, mais ces éléments constituent un bon point de départ. Pour plus d'éléments et d'explications détaillées, consultez la [liste de contrôle qualité des processus, fournie par DeFiSafety](https://docs.defisafety.com/review-process-documentation/process-quality-audit-process). [DefiSafety](https://defisafety.com/) est un service public non officiel qui publie des avis sur diverses DApps Ethereum publiques de grande taille. Une partie du système d'évaluation de DeFiSafety comprend la façon dont le projet adhère à cette liste de contrôle qualité des processus. En suivant ces processus :
+L'enregistrement d'une seule adresse en tant que `Owner` dans un contrat intelligent introduit un risque de centralisation et représente un point de défaillance unique. Si les clés de compte du propriétaire sont compromises, des attaquants peuvent attaquer le contrat détenu. C'est pourquoi utiliser un modèle de contrôle d'accès basé sur des rôles avec plusieurs comptes administratifs peut être une meilleure solution.
-- vous produirez du code plus sécurisé, via des tests reproductibles et automatisés ;
-- les experts seront en mesure de vérifier votre projet plus efficacement ;
-- l'intégration de nouveaux développeurs sera plus simple ;
-- les développeurs pourront itérer, tester et obtenir des commentaires sur les modifications rapidement ;
-- votre projet enregistrera probablement moins de régressions.
+Dans le cadre du contrôle d'accès basé sur les rôles, l'accès aux fonctions sensibles est réparti entre un ensemble de participants de confiance. Par exemple, un compte peut être responsable de la frappe des jetons, tandis qu'un autre compte peut effectuer des mises à niveau ou interrompre le contrat. Décentraliser le contrôle d'accès de cette façon élimine les points de défaillance uniques et réduit les hypothèses de confiance pour les utilisateurs.
-## Attaques et vulnérabilités {#attacks-and-vulnerabilities}
+##### Utilisation de portefeuilles multi-signature
-Maintenant que vous écrivez du code Solidity en utilisant un processus de développement efficace, examinons quelques vulnérabilités courantes de Solidity pour voir ce qui peut mal tourner.
+Une autre approche pour implémenter un contrôle d'accès sécurisé est d'utiliser un [compte multi-signature](/developers/docs/smart-contracts/#multisig) pour gérer un contrat. Contrairement à un EOA habituel, les comptes multi-signature sont détenus par plusieurs entités et nécessitent les signatures d'un nombre minimum de comptes — disons de 3 sur 5 — pour exécuter des transactions.
-### Réentrance {#re-entrancy}
+L'utilisation d'un portefeuille multi-signature pour le contrôle d'accès introduit une couche de sécurité supplémentaire dans la mesure où les actions sur le contrat cible nécessitent le consentement de plusieurs parties. Ceci est particulièrement utile si l'utilisation du modèle Ownable est nécessaire, car il rend plus difficile pour un attaquant ou un initié malhonnête de manipuler des fonctions sensibles du contrat à des fins malveillantes.
-La réentrance est l'un des problèmes de sécurité les plus importants à considérer lors du développement de contrats intelligents. L'EVM ne pouvant pas exécuter plusieurs contrats en même temps, un contrat appelant un autre contrat met en pause l'exécution du contrat appelant et l'état de la mémoire jusqu'à ce que l'appel revienne, événement à partir duquel l'exécution reprend normalement. Cette pause et cette reprise peuvent créer une vulnérabilité connue sous le nom de "réentrance".
+### 2. Utiliser les commandes require(), assert() et revert() pour protéger les opérations de contrat {#use-require-assert-revert}
-Voici une version simple d'un contrat vulnérable à la réentrance :
+Comme mentionné, n'importe qui peut appeler des fonctions publiques de votre contrat intelligent une fois qu'il est déployé sur la blockchain. Comme vous ne pouvez pas savoir à l'avance comment les comptes externes interagiront avec un contrat, il est idéal de mettre en œuvre des protections internes contre les opérations problématiques avant le déploiement. Vous pouvez imposer un comportement correct dans les contrats intelligents en utilisant les fonctions `require()`, `assert()`, et `revert()` pour déclencher des exceptions et annuler les changements d'état si l'exécution ne répond pas à certaines exigences.
-```solidity
-// CE CONTRAT A UNE VULNÉRABILITÉ INTENTIONNELLE, NE PAS COPIER
-contract Victim {
- mapping (address => uint256) public balances;
+**`require()`** : `require` sont définis en début de fonction et cela garantit que des conditions prédéfinies sont remplies avant l'exécution de la fonction appelée. Une instruction `require` peut être utilisée pour valider les entrées utilisateur, vérifier les variables d'état, ou authentifier l'identité du compte appelant avant d'exécuter la fonction.
- function deposit() external payable {
- balances[msg.sender] += msg.value;
+**`assert()`**: `assert()` est utilisée pour détecter les erreurs internes et vérifier les violations des « invariants » dans votre code. Un invariant est une assertion logique à propos de l’état d’un contrat qui devrait être vrai pour toutes les exécutions de fonctions. Un exemple d'invariant est la quantité maximale totale ou le solde d'un contrat de jeton. L'utilisation de la fonction `assert()` garantit que votre contrat n'atteint jamais un état vulnérable, et si c'est le cas malgré tout que toutes les modifications apportées aux variables d'état sont annulées.
+
+**`revert()`** : `revert()` peut être utilisé dans une instruction if-else qui déclenche une exception si la condition demandée n'est pas satisfaite. L'exemple de contrat ci-dessous utilise `revert()` pour proteger l'exécution des fonctions :
+
+```
+pragma solidity ^0.8.4;
+
+contract VendingMachine {
+ address owner;
+ error Unauthorized();
+ function buy(uint amount) public payable {
+ if (amount > msg.value / 2 ether)
+ revert("Not enough Ether provided.");
+ // Perform the purchase.
}
+ function withdraw() public {
+ if (msg.sender != owner)
+ revert Unauthorized();
- function withdraw() external {
- uint256 amount = balances[msg.sender];
- (bool success, ) = msg.sender.call.value(amount)("");
- require(success);
- balances[msg.sender] = 0;
+ payable(msg.sender).transfer(address(this).balance);
}
}
```
-Pour permettre à un utilisateur de retirer l'ETH qu'il a précédemment stocké dans le contrat, cette fonction :
+### 3. Tester les contrats intelligents et vérifier la justesse du code {#test-smart-contracts-and-verify-code-correctness}
+
+L'immuabilité du code exécuté dans la [Machine Virtuelle Ethereum](/developers/docs/evm/) signifie que les contrats intelligents exigent un plus haut niveau d'évaluation de la qualité pendant la phase de développement. Tester votre contrat de manière intensive et l'observer pour déceler tout résultat inattendu améliorera considérablement la sécurité et protégera vos utilisateurs sur le long terme.
+
+La méthode habituelle est d'écrire de petits tests unitaires à l'aide de données fictives que le contrat devrait recevoir de la part des utilisateurs. [Le test unitaire](/developers/docs/smart-contracts/testing/#unit-testing) est bon pour tester la fonctionnalité de certaines fonctions et pour s'assurer qu'un contrat intelligent fonctionne comme prévu.
+
+Malheureusement, les tests unitaires sont peu efficaces pour améliorer la sécurité des contrats intelligents lorsqu'ils sont utilisés isolément. Un test unitaire peut prouver qu'une fonction s'exécute correctement pour les données simulées, mais les tests unitaires sont seulement aussi efficaces que les tests écrits. Il est donc difficile de détecter les cas et les vulnérabilités marginaux manqués qui pourraient nuire à la sécurité de votre contrat intelligent.
+
+Une meilleure approche est de combiner les tests unitaires avec des tests fondés sur les propriétés effectués en utilisant [l'analyse statique et dynamique](/developers/docs/smart-contracts/testing/#static-dynamic-analysis). L'analyse statique repose sur des représentations de bas niveau, tels que [des graphiques de flux de contrôle](https://en.wikipedia.org/wiki/Control-flow_graph) et [des arbres de syntaxe abstraite](https://deepsource.io/glossary/ast/) pour analyser les états de programme et les chemins d'exécution accessibles. D'autre part, les techniques d'analyse dynamique, telles que le fuzzing, exécutent du code de contrat avec des valeurs d'entrées aléatoires pour détecter les opérations qui violent les propriétés de sécurité.
+
+[La vérification formelle](/developers/docs/smart-contracts/formal-verification) est une autre technique de vérification des propriétés de sécurité dans les contrats intelligents. Contrairement aux tests réguliers, la vérification formelle peut prouver de façon concluante l'absence d'erreurs dans un contrat intelligent. Ceci est réalisé en créant une spécification formelle qui permet de saisir les propriétés de sécurité désirées et de prouver qu'un modèle formel des contrats adhère à cette spécification.
+
+### 4. Demander une revue indépendante de votre code {#get-independent-code-reviews}
+
+Après avoir testé votre contrat, il est bon de demander à d'autres de vérifier le code source pour tout problème de sécurité. Les tests ne décèleront pas toutes les failles d'un contrat intelligent, mais obtenir un examen indépendant augmente la possibilité de détecter les vulnérabilités.
+
+#### Audits {#audits}
+
+Demander un audit des contrats intelligents est une façon de procéder à un examen indépendant du code. Les vérificateurs jouent un rôle important en veillant à ce que les contrats intelligents soient sécurisés et exempts de défauts de qualité et d'erreurs de conception.
+
+Cela dit, évitez de considérer les audits comme un remède miracle. Les audits de contrats intelligents ne saisiront pas chaque bogue et sont principalement conçus pour fournir une série de revues complémentaires, qui peut aider à détecter les problèmes qui auront échappé aux développeurs lors du développement et du test initial. Suivez également [les bonnes pratiques pour travailler avec les auditeurs](https://twitter.com/tinchoabbate/status/1400170232904400897), comme documenter le code correctement et ajouter de commentaires en ligne, pour maximiser les avantages d'un audit des contrats intelligents.
+
+#### Chasse à la prime {#bug-bounties}
+
+La mise en place d'un programme de prime de bogues est une autre approche pour implémenter des examens de code externes. Une prime de bogue est une récompense financière donnée aux individus (généralement des hackers whitehat) qui découvrent des vulnérabilités dans une application.
+
+Lorsqu'elle est utilisée correctement, la primes de bogues incitent les membres de la communauté hacker à inspecter votre code pour trouver des défauts critiques. Un exemple réel est le « bogue d'argent infini » qui aurait permis à un attaquant de créer un nombre illimité d'Ether sur [Optimisme](https://www.optimism.io/), un protocole [Couche 2](https://ethereum.org/en/layer-2/) fonctionnant sur Ethereum. Heureusement, un hacker whitehat [a découvert le défaut](https://www.saurik.com/optimism.html) et l'a notifié à l'équipe, [gagnant une grosse prime ce faisant](https://cryptoslate.com/critical-bug-in-ethereum-l2-optimism-2m-bounty-paid/).
+
+Une stratégie utile est de définir le paiement d'un programme de prime de bogues proportionnellement au montant des fonds mis en jeu. Décrit comme la «[mise à l'échelle de la prime de bogue](https://medium.com/immunefi/a-defi-security-standard-the-scaling-bug-bounty-9b83dfdc1ba7)», cette approche fournit des incitations financières pour les individus à divulguer de manière responsable des vulnérabilités au lieu de les exploiter.
+
+### 5. Suivre les bonnes pratiques lors du développement de contrats intelligents {#follow-smart-contract-development-best-practices}
+
+L’existence d’audits et de primes de bogue n'exclut pas votre responsabilité d’écrire un code de haute qualité. Une bonne sécurité du contrat intelligent commence en suivant des processus de conception et de développement adéquats :
+
+- Stocker tout le code dans un système de contrôle de version, tel que git
+
+- Effectuer toutes les modifications de code via des pulls requests
+
+- Assurez-vous que les pulls requests ont au moins un réviseur indépendant — si vous travaillez en solo sur un projet, envisagez de trouver d'autres développeurs et d'échanger mutuellement vos avis sur le code
+
+- Utilisez un [environnement de développement](/developers/docs/frameworks/) pour tester, compiler, déployer des contrats intelligents
+
+- Exécutez votre code sur des outils d'analyse de code basiques, tels que Mythril et Slither. Idéalement, vous devriez le faire avant de fusionner chaque pull request et comparer les différences de sortie
+
+- Assurez-vous que votre code est compilé sans erreurs, et que le compilateur Solidity n'émet aucun avertissement
+
+- Documentez correctement votre code (en utilisant [NatSpec](https://solidity.readthedocs.io/en/develop/natspec-format.html)) et décrivez les détails sur l'architecture du contrat dans un langage facile à comprendre. Cela facilitera l'audit et l'examen de votre code pour les autres.
+
+### 6. Mettre en œuvre des plans de relance robustes en cas de catastrophe {#implement-disaster-recovery-plans}
+
+La conception de contrôles d'accès sécurisés, la mise en œuvre de modificateurs de fonction et d'autres suggestions peuvent améliorer la sécurité des contrats intelligents, mais elles ne peuvent pas exclure la possibilité d'exploits malveillants. Pour élaborer des contrats intelligents sécurisés, il faut se « préparer à l'échec » et disposer d'un plan de repli pour répondre efficacement aux attaques. Un plan de reprise après sinistre adéquat intègre tout ou partie des éléments suivants :
+
+#### Mise à niveau du contrat {#contract-upgrades}
+
+Bien que les contrats intelligents Ethereum soient immuables par défaut, il est possible d'obtenir un certain degré de mutabilité en utilisant des modèles de mise à niveau. La mise à niveau des contrats est nécessaire dans les cas où une faille critique rend votre ancien contrat inutilisable et où le déploiement d'une nouvelle logique est l'option la plus réalisable.
-1. lit le solde de l'utilisateur ;
-2. lui envoie le solde en ETH ;
-3. réinitialise le solde à 0, de sorte que l'utilisateur ne puisse pas retirer le solde de nouveau.
+Les mécanismes de mise à niveau des contrats fonctionnent différemment, mais le « modèle proxy » est l'une des approches les plus populaires pour la mise à niveau des contrats intelligents. Les modèles de proxy divisent l'état et la logique d'une application entre _deux_ contrats. Le premier contrat (appelé « contrat mandataire ») stocke les variables d'état (par exemple, les soldes des utilisateurs), tandis que le second contrat (appelé « contrat logique ») contient le code d'exécution des fonctions du contrat.
-Si elle est appelée à partir d'un compte normal (comme celui de votre propre compte MetaMask), elle fonctionne comme prévu : msg.sender.call.value() envoie simplement l'ETH vers votre compte. Toutefois, les contrats intelligents peuvent également effectuer des appels. Si un contrat personnalisé et malveillant appelle la fonction `withdraw()`, msg.sender.call.value() n'enverra pas le montant d'ETH (via `amount`), mais appellera aussi implicitement le contrat pour commencer à exécuter du code. Imaginez le contrat malveillant suivant :
+Les comptes interagissent avec le contrat du mandataire, qui envoie tous les appels de fonction au contrat logique en utilisant l'appel de bas niveau [`delegatecall()`](https://docs.soliditylang.org/en/v0.8.16/introduction-to-smart-contracts.html?highlight=delegatecall#delegatecall-callcode-and-libraries). Contrairement à un appel de message ordinaire, `delegatecall()` garantit que le code exécuté à l'adresse du contrat logique est exécuté dans le contexte du contrat appelant. Cela signifie que le contrat logique écrira toujours dans le stockage du proxy (au lieu de son propre stockage) et les valeurs originales des `msg.sender` et `msg.value` sont préservées.
+
+La délégation des appels au contrat logique nécessite de stocker son adresse dans le stockage du contrat de procuration. Par conséquent, la mise à niveau de la logique du contrat consiste simplement à déployer un autre contrat logique et à stocker la nouvelle adresse dans le contrat de procuration. Comme les appels ultérieurs au contrat de procuration sont automatiquement acheminés vers le nouveau contrat logique, vous aurez « mis à niveau » le contrat sans modifier réellement le code.
+
+[En savoir plus sur la mise à niveau des contrats](/developers/docs/smart-contracts/upgrading/).
+
+#### Arrêts d'urgence {#emergency-stops}
+
+Comme nous l'avons mentionné, les audits et les tests approfondis ne peuvent pas découvrir tous les bugs d'un contrat intelligent. Si une vulnérabilité apparaît dans votre code après le déploiement, il est impossible de la corriger puisque vous ne pouvez pas modifier le code exécuté à l'adresse du contrat. De plus, les mécanismes de mise à niveau ( par exemple, les modèles de procuration) peuvent prendre du temps à se mettre en œuvre (ils nécessitent souvent l'approbation de différentes parties), ce qui ne fait que donner plus de temps aux attaquants pour causer plus de dommages.
+
+L'option nucléaire consiste à mettre en œuvre une fonction « d'arrêt d'urgence » qui bloque les appels aux fonctions vulnérables dans un contrat. Les arrêts d'urgence comprennent généralement les composants suivants :
+
+1. Une variable booléenne globale indiquant si le contrat intelligent est dans un état arrêté ou non. Cette variable est définie à `false` lors de la mise en place du contrat, mais elle deviendra `vraie` une fois le contrat arrêté.
+
+2. Les fonctions qui font référence à la variable booléenne dans leur exécution. Ces fonctions sont accessibles lorsque le contrat intelligent n'est pas arrêté, et deviennent inaccessibles lorsque la fonction d'arrêt d'urgence est déclenchée.
+
+3. Une entité qui a accès à la fonction d'arrêt d'urgence, qui définit la variable booléenne à `true`. Pour éviter les actions malveillantes, les appels à cette fonction peuvent être limités à une adresse de confiance (par exemple, le propriétaire du contrat).
+
+Une fois que le contrat a activé l'arrêt d'urgence, certaines fonctions ne seront pas appelables. Pour ce faire, les fonctions de sélection sont enveloppées dans un modificateur qui fait référence à la variable globale. Voici [un exemple](https://github.com/fravoll/solidity-patterns/blob/master/EmergencyStop/EmergencyStop.sol) décrivant une implémentation de ce modèle dans les contrats :
```solidity
-contract Attacker {
- function beginAttack() external payable {
- Victim(VICTIM_ADDRESS).deposit.value(1 ether)();
- Victim(VICTIM_ADDRESS).withdraw();
+// Ce code n'a pas fait l'objet d'un audit professionnel et ne fait aucune promesse quant à sa sécurité ou son exactitude. Utilisez-le à vos risques et périls.
+
+contract EmergencyStop {
+
+ bool isStopped = false;
+
+ modifier stoppedInEmergency {
+ require(!isStopped);
+ _;
}
- function() external payable {
- if (gasleft() > 40000) {
- Victim(VICTIM_ADDRESS).withdraw();
- }
+ modifier onlyWhenStopped {
+ require(isStopped);
+ _;
+ }
+
+ modifier onlyAuthorized {
+ // Check for authorization of msg.sender here
+ _;
+ }
+
+ function stopContract() public onlyAuthorized {
+ isStopped = true;
+ }
+
+ function resumeContract() public onlyAuthorized {
+ isStopped = false;
+ }
+
+ function deposit() public payable stoppedInEmergency {
+ // Deposit logic happening here
+ }
+
+ function emergencyWithdraw() public onlyWhenStopped {
+ // Emergency withdraw happening here
}
}
```
-Appeler Attacker.beginAttack() démarrera un cycle qui ressemble à quelque chose comme ça :
+Cet exemple montre les caractéristiques de base des arrêts d'urgence :
-```
-0.) Attacker's EOA calls Attacker.beginAttack() with 1 ETH
-0.) Attacker.beginAttack() deposits 1 ETH into Victim
-
- 1.) Attacker -> Victim.withdraw()
- 1.) Victim reads balances[msg.sender]
- 1.) Victim sends ETH to Attacker (which executes default function)
- 2.) Attacker -> Victim.withdraw()
- 2.) Victim reads balances[msg.sender]
- 2.) Victim sends ETH to Attacker (which executes default function)
- 3.) Attacker -> Victim.withdraw()
- 3.) Victim reads balances[msg.sender]
- 3.) Victim sends ETH to Attacker (which executes default function)
- 4.) Attacker no longer has enough gas, returns without calling again
- 3.) balances[msg.sender] = 0;
- 2.) balances[msg.sender] = 0; (it was already 0)
- 1.) balances[msg.sender] = 0; (it was already 0)
-```
+- `isStopped` est un booléen qui évalue à `false` en début et à `true` lorsque le contrat entre en mode d'urgence.
-Appeller Attacker.beginAttack avec 1 ETH génère une nouvelle attaque par réentrance contre la victime, retirant plus d'ETH qu'il n'en a été fourni (prélevé sur les soldes des autres utilisateurs, entraînant une sous-garantie du contrat de la victime)
+- Les modificateurs de fonction `onlyWhenStopped` et `stoppedInEmergency` vérifient la variable `isStopped`. `stoppedInEmergency` est utilisé pour piloter des fonctions qui doivent être inaccessibles lorsque le contrat est vulnérable (par exemple : `deposit()`). Les appels à ces fonctions seront tout simplement annulés.
-### Comment gérer la réentrance (de la mauvaise façon) {#how-to-deal-with-re-entrancy-the-wrong-way}
+`onlyWhenStopped` est utilisé pour des fonctions qui doivent être appelables pendant une urgence (par exemple, `emergencyWithdraw()`). De telles fonctions peuvent aider à résoudre la situation, d’où leur exclusion de la liste des « fonctions restreintes ».
-On pourrait envisager de contrecarrer la réentrance en empêchant simplement les contrats intelligents d'interagir avec votre code. Vous recherchez stackoverflow, vous trouvez cet extrait de code avec des tonnes de votes positifs :
+L'utilisation d'une fonctionnalité d'arrêt d'urgence constitue un palliatif efficace pour faire face aux vulnérabilités graves de votre contrat intelligent. Cependant, les utilisateurs doivent faire confiance aux développeurs pour qu'ils ne l'activent pas pour des raisons intéressées. À cette fin, décentraliser le contrôle de l'arrêt d'urgence soit en le soumettant à un mécanisme de vote en chaîne, un timelock, ou à l'approbation d'un portefeuille multisig sont des solutions possibles.
-```solidity
-function isContract(address addr) internal returns (bool) {
- uint size;
- assembly { size := extcodesize(addr) }
- return size > 0;
-}
-```
+#### Suivi des événements {#event-monitoring}
+
+[Les événements](https://docs.soliditylang.org/en/v0.8.15/contracts.html#events) vous permettent de suivre les appels vers les fonctions des contrats intelligents et de surveiller les changements apportés aux variables d'état. Il est idéal de programmer votre contrat intelligent pour qu'il émette un événement chaque fois qu'une partie prend une mesure critique en matière de sécurité (par exemple, retirer des fonds).
+
+Le log des événements et leur surveillance hors chaîne fournissent un aperçu des opérations contractuelles et aide à la découverte plus rapide des actions malveillantes. Cela signifie que votre équipe peut réagir plus rapidement aux hacks et prendre des mesures pour atténuer l'impact sur les utilisateurs, tels que suspendre les fonctions ou effectuer une mise à niveau.
+
+Vous pouvez également opter pour un outil de surveillance en vente libre qui transmet automatiquement les alertes lorsque quelqu'un interagit avec vos contrats. Ces outils vous permettent de créer des alertes personnalisées basées sur différents déclencheurs, comme le volume de la transaction, la fréquence des appels de fonctions, ou les fonctions spécifiques impliquées. Par exemple, vous pouvez programmer une alerte qui arrive lorsque le montant retiré en une seule opération dépasse un seuil particulier.
+
+### 7. Concevoir des systèmes de gouvernance sécurisés {#design-secure-governance-systems}
+
+Vous voudrez peut-être décentraliser votre application en transférant le contrôle des contrats intelligents de base aux membres de la communauté. Dans ce cas, le système de contrats intelligents comprendra un module de gouvernance, un mécanisme qui permet aux membres de la communauté d'approuver des actions administratives via un système de gouvernance en chaîne. Par exemple, une proposition de mise à niveau d'un contrat de procuration vers une nouvelle implémentation peut être votée par les détenteurs de jetons.
+
+Une gouvernance décentralisée peut être bénéfique, en particulier parce qu'elle aligne les intérêts des développeurs et des utilisateurs finaux. Néanmoins, les mécanismes de gouvernance des contrats intelligents peuvent introduire de nouveaux risques s'ils sont mal mis en œuvre. Un scénario plausible est si un attaquant acquiert un énorme pouvoir de vote (mesuré en nombre de jetons conservés) en prenant un [crédit flash](/defi/#flash-loans) et en poussant une proposition malveillante.
+
+Une façon de prévenir les problèmes liés à la gouvernance sur la chaîne est d'utiliser [un timelock](https://blog.openzeppelin.com/protect-your-users-with-smart-contract-timelocks/). Un timelock empêche un contrat intelligent d'exécuter certaines actions jusqu'à ce qu'un certain temps passe. D'autres stratégies incluent l'assignation d'une « pondération de vote » à chaque jeton en fonction de la durée d'enfermement de chaque jeton, ou mesurant le pouvoir de vote d'une adresse à une période historique (par exemple, 2-3 blocs dans le passé) au lieu du bloc actuel. Les deux méthodes réduisent la possibilité d’amasser rapidement le pouvoir de vote pour basculer sur les votes en chaîne.
+
+En savoir plus sur [la conception de systèmes de gouvernance sécurisée](https://blog.openzeppelin.com/smart-contract-security-guidelines-4-strategies-for-safer-governance-systems/) et [de mécanismes de vote différents dans les DAO](https://hackernoon.com/governance-is-the-holy-grail-for-daos).
+
+### 8. Réduire la complexité du code à un minimum {#reduce-code-complexity}
+
+Les développeurs de logiciels traditionnels sont familiers avec le principe KISS (« keep it simple, stupid ») qui recommande de ne pas introduire de complexité inutile dans la conception de logiciels. Cela fait suite à la pensée de longue date selon laquelle « les systèmes complexes échouent de manière complexe » et sont plus susceptibles d’être confrontés à des erreurs coûteuses.
-Cela semble sensé : les contrats ont du code, si l'appelant a du code, cele ne l'autorise pas à déposer. Tentons de l'ajouter :
+Garder les choses simples est particulièrement important lors de la rédaction de contrats intelligents, étant donné que les contrats intelligents contrôlent potentiellement de grandes quantités de valeur. Une astuce pour atteindre la simplicité lors de l'écriture de contrats intelligents est de réutiliser des bibliothèques existantes, telles que les [contrats OpenZeppelin](https://docs.openzeppelin.com/contracts/4.x/), lorsque cela est possible. Parce que ces bibliothèques ont été largement vérifiées et testées par les développeurs, leur utilisation réduit les chances d'introduire des bogues en écrivant de nouvelles fonctionnalités à partir de zéro.
+
+Un autre conseil commun est d'écrire de petites fonctions et de garder les contrats modulaires en divisant la logique commerciale entre plusieurs contrats. Non seulement l'écriture de code plus simple réduit la surface d'attaque dans un contrat intelligent, mais il est également plus facile de raisonner sur la justesse du système global et de détecter les éventuelles erreurs de conception plus tôt.
+
+### 9. Protéger contre les vulnérabilités communes des contrats intelligents {#mitigate-common-smart-contract-vulnerabilities}
+
+#### Réentrance {#reentrancy}
+
+L’EVM ne permet pas la simultanéité, ce qui signifie que deux contrats impliqués dans un appel de message ne peuvent pas être exécutés simultanément. Un appel externe met en pause l'exécution et la mémoire du contrat d'appel jusqu'à ce que l'appel revienne, à partir duquel l'exécution du point se déroule normalement. Ce processus peut être décrit formellement comme le transfert du [flux de contrôle](https://www.computerhope.com/jargon/c/contflow.htm) vers un autre contrat.
+
+Bien que la plupart du temps inoffensifs, le transfert de flux de contrôle vers des contrats non approuvés peut causer des problèmes, tels que la réentrance. Une attaque par réentrance survient lorsqu'un contrat malveillant rappelle un contrat vulnérable avant que l'invocation de la fonction d'origine ne soit terminée. Ce type d'attaque est mieux expliqué avec un exemple.
+
+Considérez un simple contrat intelligent (« Victim ») qui permet à quiconque de déposer et de retirer de l'Ether :
```solidity
-// CE CONTRAT A UNE VULNÉRABILITÉ INTENTIONNELLE, NE PAS COPIER
-contract ContractCheckVictim {
- mapping (address => uint256) public balances;
+// This contract is vulnerable. Do not use in production
- function isContract(address addr) internal returns (bool) {
- uint size;
- assembly { size := extcodesize(addr) }
- return size > 0;
- }
+contract Victim {
+ mapping (address => uint256) public balances;
function deposit() external payable {
- require(!isContract(msg.sender)); // <- NEW LINE
balances[msg.sender] += msg.value;
}
@@ -155,39 +253,61 @@ contract ContractCheckVictim {
}
```
-Maintenant pour déposer de l'ETH, vous ne devez pas avoir de code de contrat intelligent à votre adresse. Ceci est néanmoins facilement surmonté avec le contrat d'attaquant suivant :
+Ce contrat expose une fonction `withdraw()` pour permettre aux utilisateurs de retirer de l'ETH précédemment déposé dans le contrat. Lors du traitement d'un retrait, le contrat effectue les opérations suivantes :
-```solidity
-contract ContractCheckAttacker {
- constructor() public payable {
- ContractCheckVictim(VICTIM_ADDRESS).deposit(1 ether); // <- New line
- }
+1. Vérifie le solde ETH de l'utilisateur
+2. Envoie des fonds à l'adresse d'appel
+3. Réinitialise son solde à 0, empêchant les retraits supplémentaires de l'utilisateur
+
+La fonction `withdraw()` dans le contrat `Victim` suit un modèle « checks-interactions-effects ». Il _vérifie_ si les conditions nécessaires à l'exécution sont satisfaites (c.-à-d. l'utilisateur a un solde ETH positif) et effectue l'interaction \__ en envoyant l'ETH à l'adresse de l'appelant, avant d'appliquer les \_effets_ de la transaction (c.-à-d., réduisant le solde de l’utilisateur).
+
+Si la fonction `withdraw()` est appelée depuis un compte externe (Externally Orné Account, dit EOA), la fonction s'exécute comme attendu : `msg.sender.call.value()` envoie l'ETH à l'appelant. Cependant, si `msg.sender` est un compte de contrat intelligent qui appelle `withdraw()`, l'envoie de fonds en utilisant `msg.sender.call.value()` déclenchera également le code stocké à cette adresse pour l'exécuter.
+Imaginez qu'il s'agisse du code déployé à l'adresse du contrat:
+
+```solidity
+ contract Attacker {
function beginAttack() external payable {
- ContractCheckVictim(VICTIM_ADDRESS).withdraw();
+ Victim(victim_address).deposit.value(1 ether)();
+ Victim(victim_address).withdraw();
}
function() external payable {
if (gasleft() > 40000) {
- Victim(VICTIM_ADDRESS).withdraw();
+ Victim(victim_address).withdraw();
}
- }
+ }
}
```
-Alors que la première attaque était une attaque sur la logique du contrat, il s'agit maintenant d'une attaque sur le comportement de déploiement du contrat Ethereum. Pendant la construction, un contrat n'a pas encore renvoyé le code à déployer à son adresse, mais conserve le contrôle complet de l'EVM DURANT ce processus.
+Ce contrat est conçu pour faire trois choses :
+
+1. Accepter un dépôt depuis un autre compte (probablement l’EOA de l’attaquant)
+2. Dépose 1 ETH dans le contrat Victim
+3. Retirer 1 ETH stocké dans le contrat intelligent
-Il est techniquement possible d'empêcher les contrats intelligents d'appeler votre code, en utilisant cette ligne :
+Il n'y a rien de mal ici, excepté que l'`Attacker` a une autre fonction qui appelle `withdraw()` dans `Victim` à nouveau si le gaz restant du `msg.sender.call.value` entrant est supérieur à 40 000. Cela donne à l'`Attacker` la possibilité de rentrer `Victim` et de retirer plus de fonds _avant que_ la première invocation de `withdraw` soit terminée. Le cycle ressemble à ceci:
```solidity
-require(tx.origin == msg.sender)
+- L'EOA de l'attaquant appelle `Attacker.beginAttack()` avec 1 ETH
+- `Attaquant.beginAttack()` dépose 1 ETH dans `Victim`
+- `Attacker` appelle `withdraw() dans `Victim`
+- `Victim` vérifie le solde de `Attacker` (1 ETH)
+- `Victim` envoie 1 ETH à `Attacker` (qui déclenche la fonction par défaut)
+- `Attacker` appelle `Victim.withdraw()` à nouveau (notez que `Victim` n'a pas réduit le solde de `Attacker` à partir du premier retrait)
+- `Victim` vérifie le solde de `Attacker` (qui est toujours 1 ETH car il n'a pas appliqué les effets du premier appel)
+- `Victim` envoie 1 ETH à `Attacker` (qui déclenche la fonction par défaut et permet à `Attacker` de réintroduire la fonction `withdraw`)
+- Le processus se répète jusqu'à ce que `Attacker` soit épuisé, à quel point `msg.sender.call.value` retourne sans déclencher de retraits supplémentaires
+- `Victim` applique enfin les résultats de la première transaction (et de celles subséquentes) à son état, donc le solde de `Attacker` est fixé à 0
```
-Cependant, ce n'est toujours pas une bonne solution. L'un des aspects les plus passionnants d'Ethereum est sa composabilité : ses contrats intelligents s'intègrent et se construisent les uns avec les autres. En utilisant la ligne ci-dessus, vous limitez l'utilité de votre projet.
+Le résumé est que, comme le solde de l'appelant n'est pas défini à 0 jusqu'à ce que l'exécution de la fonction soit terminée, les invocations suivantes réussiront et permettront à l'appelant de retirer son solde plusieurs fois. Ce type d'attaque peut être utilisé pour drainer un contrat intelligent de ses fonds, comme ce qui s'est passé dans le hack [DAO 2016](https://www.coindesk.com/learn/2016/06/25/understanding-the-dao-attack/). Les attaques par réentrance sont toujours un problème critique pour les contrats intelligents aujourd'hui, comme le montre [les listes publiques des exploits de réentrance](https://github.com/pcaversaccio/reentrancy-attacks).
+
+##### Comment empêcher les attaques par réentrance
-### Comment gérer la réentrance (de la bonne façon) {#how-to-deal-with-re-entrancy-the-right-way}
+Une approche pour traiter la réentrance est de suivre le [modèle de vérifications-effets-interactions](https://docs.soliditylang.org/en/develop/security-considerations.html#use-the-checks-effects-interactions-pattern). Ce modèle ordonne l'exécution de fonctions d'une manière que le code qui effectue les vérifications nécessaires avant de progresser avec l'exécution arrive en premier, suivi du code qui manipule l'état du contrat, avec du code qui interagit avec d'autres contrats ou EOA arrivant en dernier.
-En changeant simplement l'ordre de la mise à jour de stockage et de l'appel externe, nous empêchons la condition de réentrance qui a permis l'attaque. Un rappel vers un retrait, bien que possible, ne profitera pas à l'attaquant puisque le stockage des `soldes` sera déjà défini à 0.
+Le modèle de vérifications-effets-interactions est utilisé dans une version révisée du contrat `Victim` affichée ci-dessous :
```solidity
contract NoLongerAVictim {
@@ -200,128 +320,234 @@ contract NoLongerAVictim {
}
```
-Le code ci-dessus suit le modèle de conception "Checks-Effects-Interactions", qui aide à se protéger contre la réentrance. En savoir plus sur le modèle [Checks-Effects-Interactions](https://fravoll.github.io/solidity-patterns/checks_effects_interactions.html)
+Ce contrat effectue un _check_ sur le solde de l'utilisateur, applique les _effects_ de la fonction `withdraw()` (en réinitialisant le solde de l'utilisateur à 0), et procède à l’exécution de l'_interaction_ (envoi de l’ETH à l’adresse de l’utilisateur). Cela garantit que le contrat met à jour son stockage avant l’appel externe, éliminant ainsi la condition de réentrance qui a permis la première attaque. Le contrat `Attacker` pourrait toujours être rappelé dans `NoLongerAVictim`, mais depuis que `balances[msg.sender]` a été réglé à 0, les retraits supplémentaires lanceront une erreur.
-### Comment gérer la réentrance (l'option nucléaire) {#how-to-deal-with-re-entrancy-the-nuclear-option}
+Une autre option est d'utiliser un verrou d'exclusion mutuelle (communément décrit comme un « mutex ») qui verrouille une partie de l'état d'un contrat jusqu'à ce qu'une invocation de fonction soit terminée. Ceci est implémenté en utilisant une variable booléenne qui est définie à `true` avant que la fonction ne s'exécute et retourne à `false` après que l'invocation ait été faite. Comme on le voit dans l'exemple ci-dessous, l'utilisation d'un mutex protège une fonction contre les appels récursifs alors que l'invocation originale est toujours en cours de traitement, empêchant ainsi efficacement la réentrance.
-Chaque fois que vous envoyez de l'ETH à une adresse non fiable ou que vous interagissez avec un contrat inconnu (comme appeler le "`transfer()`" d'une adresse de jeton fournie par l'utilisateur), vous vous exposez à un risque de réentrance. **En concevant des contrats qui n'envoient pas d'ETH et n'appellent pas de contrats non fiables, vous empêchez la possiblité de réentrance !**
+```solidity
+pragma solidity ^0.7.0;
-## Autres types d'attaques {#more-attack-types}
+contract MutexPattern {
+ bool locked = false;
+ mapping(address => uint256) public balances;
-Les types d'attaque ci-dessus couvrent les problèmes de codage de contrats intelligents (réentrance) et les anomalies Ethereum (exécution de code dans les constructeurs de contrats, avant que le code ne soit disponible à l'adresse du contrat). Il existe beaucoup, beaucoup d'autres types d'attaque à connaître, y compris :
+ modifier noReentrancy() {
+ require(!locked, "Blocked from reentrancy.");
+ locked = true;
+ _;
+ locked = false;
+ }
+ // This function is protected by a mutex, so reentrant calls from within `msg.sender.call` cannot call `withdraw` again.
+ // The `return` statement evaluates to `true` but still evaluates the `locked = false` statement in the modifier
+ function withdraw(uint _amount) public payable noReentrancy returns(bool) {
+ require(balances[msg.sender] >= _amount, "No balance to withdraw.");
-- Front running
-- Rejet d'envoi d'ETH
-- Dépassement/sous-flux d'entier
+ balances[msg.sender] -= _amount;
+ bool (success, ) = msg.sender.call{value: _amount}("");
+ require(success);
+
+ return true;
+ }
+}
+```
-Complément d'information:
+Vous pouvez également utiliser un système de [« pull payments »](https://docs.openzeppelin.com/contracts/4.x/api/security#PullPayment) qui demande aux utilisateurs de retirer des fonds des contrats intelligents, au lieu d'un système de paiement « push payments » qui envoie des fonds à des comptes. Cela élimine la possibilité de déclencher par inadvertance du code à des adresses inconnues (et peut également prévenir certaines attaques par déni de service).
-- [Consensys Smart Contract Known Attacks](https://consensys.github.io/smart-contract-best-practices/attacks/) - Une explication très lisible des vulnérabilités les plus importantes, avec un exemple de code pour la plupart.
-- [Registre SWC](https://swcregistry.io/docs/SWC-128) - Liste conservée des CWE qui s'appliquent à Ethereum et aux contrats intelligents
+#### Soupassements et dépassements d'entier {#integer-underflows-and-overflows}
-## Outils de sécurité {#security-tools}
+Un dépassement d'entier se produit lorsque les résultats d'une opération arithmétique tombent en dehors de la plage de valeurs acceptable, le faisant passer à la valeur représentable la plus basse. Par exemple, un `uint8` ne peut stocker que des valeurs allant jusqu'à 2^8-1=255. Les opérations arithmétiques qui aboutissent à des valeurs supérieures à `255` dépasseront et réinitialiseront `uint` à `0`, similaire à la façon dont l'odomètre sur une voiture se réinitialise à 0 une fois qu'il atteint le kilométrage maximum (999999).
-Bien qu'il n'y ait pas de substitut à la compréhension des bases de sécurité d'Ethereum et à l'engagement d'un expert pour revoir votre code, il existe de nombreux outils disponibles pour aider à mettre en évidence les problèmes potentiels présents dans votre code.
+Les soupassements d'entier se produisent pour des raisons similaires : les résultats d'une opération arithmétique sont inférieurs à la fourchette acceptable. Disons que vous avez essayé de diminuer `0` dans un `uint8`, le résultat ne ferait que passer à la valeur représentative maximale (`255`).
-### Sécurité des contrats intelligents {#smart-contract-security}
+Les dépassements d'entier et les soupassements peuvent entraîner des changements inattendus dans les variables d'état d'un contrat et entraîner une exécution non planifiée. Voici un exemple montrant comment un attaquant peut exploiter un dépassement arithmétique dans un contrat intelligent pour effectuer une opération invalide :
-**Slither -** **_Infrastructure d'analyse statique Solidity rédigé en Python 3_**
+```
+pragma solidity ^0.7.6;
+
+// Ce contrat est conçu pour servir de coffre temporel.
+// L'utilisateur peut déposer dans ce contrat mais ne peut pas se retirer pendant au moins une semaine.
+// L'utilisateur peut également prolonger le temps d'attente au-delà de la période d'attente de 1 semaine.
-- [GitHub](https://github.com/crytic/slither)
+/*
+1. Déployer TimeLock
+2. Déployer l'Attaque avec l'adresse de TimeLock
+3. Appeler Attaque.attack en envoyant 1 éther. Vous pourrez immédiatement
+ retirer votre éther.
-**MythX -** **_API d'analyse de sécurité pour les contrats intelligents Ethereum_**
+Que s'est-il passé ?
+L'attaque a causé un dépassement de TimeLock.lockTime et a pu entraîner un retrait
+avant la période d'attente d'une semaine.
+*/
-- [mythx.io](https://mythx.io/)
-- [Documentation](https://docs.mythx.io/)
+contract TimeLock {
+ mapping(address => uint) public balances;
+ mapping(address => uint) public lockTime;
-**Mythril -** **_Outil d'analyse de sécurité pour le bytecode de l'EVM_**
+ function deposit() external payable {
+ balances[msg.sender] += msg.value;
+ lockTime[msg.sender] = block.timestamp + 1 weeks;
+ }
-- [mythril](https://github.com/ConsenSys/mythril)
-- [Documentation](https://mythril-classic.readthedocs.io/en/master/about.html)
+ function increaseLockTime(uint _secondsToIncrease) public {
+ lockTime[msg.sender] += _secondsToIncrease;
+ }
-**Manticore -** **_Interface en ligne de commande qui utilise un outil d'exécution symbolique sur les contrats intelligents et les fichiers binaires_**
+ function withdraw() public {
+ require(balances[msg.sender] > 0, "Insufficient funds");
+ require(block.timestamp > lockTime[msg.sender], "Lock time not expired");
-- [GitHub](https://github.com/trailofbits/manticore)
-- [Documentation](https://github.com/trailofbits/manticore/wiki)
+ uint amount = balances[msg.sender];
+ balances[msg.sender] = 0;
-**Securify -** **_Scanner de sécurité pour les contrats intelligents Ethereum_**
+ (bool sent, ) = msg.sender.call{value: amount}("");
+ require(sent, "Failed to send Ether");
+ }
+}
-- [securify.chainsecurity.com](https://securify.chainsecurity.com/)
-- [Discord](https://discordapp.com/invite/nN77ckb)
+contract Attack {
+ TimeLock timeLock;
-**ERC20 Verifier -** **_Outil utilisé pour vérifier qu'un contrat est conforme à la norme ERC20_**
+ constructor(TimeLock _timeLock) {
+ timeLock = TimeLock(_timeLock);
+ }
-- [erc20-verifier.openzeppelin.com](https://erc20-verifier.openzeppelin.com)
-- [Forum](https://forum.openzeppelin.com/t/online-erc20-contract-verifier/1575)
+ fallback() external payable {}
+
+ function attack() public payable {
+ timeLock.deposit{value: msg.value}();
+ /*
+ if t = current lock time then we need to find x such that
+ x + t = 2**256 = 0
+ so x = -t
+ 2**256 = type(uint).max + 1
+ so x = type(uint).max + 1 - t
+ */
+ timeLock.increaseLockTime(
+ type(uint).max + 1 - timeLock.lockTime(address(this))
+ );
+ timeLock.withdraw();
+ }
+}
+```
-### Vérification formelle {#formal-verification}
+##### Comment éviter les soupassements et dépassements d'entier
-**Informations sur la vérification formelle**
+Depuis la version 0.8.0, le compilateur Solidity rejette le code qui entraîne des soupassements et dépassements d'entier. Cependant, les contrats compilés avec une version inférieure du compilateur devraient soit effectuer des vérifications sur des fonctions impliquant des opérations arithmétiques soit utiliser une bibliothèque (par ex., [SafeMath](https://docs.openzeppelin.com/contracts/2.x/api/math)) qui vérifie le soupassement/dépassement.
-- [Fonctionnement de la vérification formelle des contacts intelligents](https://runtimeverification.com/blog/how-formal-verification-of-smart-contracts-works/) _- Brian Marick, 20 juillet 2018_
-- [Comment la vérification formelle peut garantir des contrats intelligents sans faille](https://media.consensys.net/how-formal-verification-can-ensure-flawless-smart-contracts-cbda8ad99bd1) _29 - Bernard Mueller, janvier 2018_
+#### Manipulation Oracle {#oracle-manipulation}
-### Utilisation d'outils {#using-tools}
+[Les Oracles](/developers/docs/oracles/) sourcent des informations hors chaîne et les envoient en chaîne pour les contrats intelligents à utiliser. Avec des oracles, vous pouvez concevoir des contrats intelligents qui interagissent avec des systèmes hors chaîne, tels que les marchés de capitaux, en élargissant considérablement leur application.
-Deux des outils les plus populaires pour l'analyse de sécurité des contrats intelligents sont :
+Mais si l'oracle est corrompu et envoie des informations incorrectes en chaîne, les contrats intelligents s'exécuteront sur la base d'entrées erronées, ce qui peut causer des problèmes. C'est la base du « problème de l'oracle », qui concerne la tâche de s'assurer que les informations provenant d'un oracle de la blockchain sont exactes, à jour et en temps opportun.
-- [Slither](https://github.com/crytic/slither) par [Trail of Bits](https://www.trailofbits.com/) (version hébergée : [Crytic](https://crytic.io/))
-- [Mythril](https://github.com/ConsenSys/mythril) par [ConsenSys](https://consensys.net/) (version hébergée : [MythX](https://mythx.io/))
+Une préoccupation liée à la sécurité consiste à utiliser un oracle en chaîne, tel qu'un échange décentralisé, pour obtenir le prix au comptant d'un actif. Les plateformes de prêt dans l'industrie [de la finance décentralisée (DeFi)](/defi/) le font souvent pour déterminer la valeur de la garantie d'un utilisateur pour déterminer le montant qu'il peut emprunter.
-Tous deux sont des outils utiles qui analysent votre code et signalent les problèmes. Chacun possède une version hébergée par [commercial], mais est également disponible gratuitement pour fonctionner localement. Voici un bref exemple de la façon d'exécuter Slither, disponible dans une image Docker pratique `trailofbits/eth-security-toolbox`. Vous devrez [installer Node.js](https://nodejs.org/) si vous ne l’avez pas déjà fait.
+Les prix des DEX sont souvent exacts, en grande partie en raison du rétablissement de la parité sur les marchés. Cependant, ils sont ouverts à la manipulation, en particulier si l'oracle sur la chaîne calcule les prix des actifs en fonction des modèles de négociation historiques (comme c'est généralement le cas).
-```bash
-$ mkdir test-slither
-$ curl https://gist.githubusercontent.com/epheph/460e6ff4f02c4ac582794a41e1f103bf/raw/9e761af793d4414c39370f063a46a3f71686b579/gistfile1.txt > bad-contract.sol
-$ docker run -v `pwd`:/share -it --rm trailofbits/eth-security-toolbox
-docker$ cd /share
-docker$ solc-select 0.5.11
-docker$ slither bad-contract.sol
-```
+Par exemple, un attaquant pourrait artificiellement pomper le prix au comptant d'un actif en souscrivant un prêt flash juste avant d'interagir avec votre contrat de prêt. Interroger le DEX pour le prix de l’actif reviendrait à une valeur plus élevée que la normale (en raison de la forte demande de transfert de « l'ordre d’achat » de l’attaquant pour l’actif), leur permettant d'emprunter plus qu'ils ne le devraient. De telles « attaques de prêts flash » ont été utilisées pour exploiter la dépendance à l'égard de prix oracles parmi les applications DeFi, coûtant des millions de protocoles en fonds perdus.
-génèrera cette sortie :
-
-```bash
-ethsec@1435b241ca60:/share$ slither bad-contract.sol
-INFO:Detectors:
-Reentrancy in Victim.withdraw() (bad-contract.sol#11-16):
- External calls:
- - (success) = msg.sender.call.value(amount)() (bad-contract.sol#13)
- State variables written after the call(s):
- - balances[msg.sender] = 0 (bad-contract.sol#15)
-Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities
-INFO:Detectors:
-Low level call in Victim.withdraw() (bad-contract.sol#11-16):
- - (success) = msg.sender.call.value(amount)() (bad-contract.sol#13)
-Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#low-level-calls
-INFO:Slither:bad-contract.sol analyzed (1 contracts with 46 detectors), 2 result(s) found
-INFO:Slither:Use https://crytic.io/ to get access to additional detectors and GitHub integration
-```
+##### Comment éviter la manipulation d'oracle
-Slither a identifié le potentiel de réentrance, ainsi que les lignes clés où le problème pourrait se produire, et nous donne un lien pour plus de détails sur le problème ici :
+Le minimum requis pour éviter la manipulation d'oracle est d'utiliser un réseau oracle décentralisé qui interroge des informations provenant de sources multiples pour éviter des points de défaillance uniques. Dans la plupart des cas, les oracles décentralisés ont des incitations cryptoéconomiques intégrées pour encourager les noeuds d'oracle à signaler des informations correctes, les rendant plus sûres que les oracles centralisés.
-> Référence : https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities
+Si vous comptez interroger un oracle sur le prix des actifs, envisagez d'utiliser un mécanisme qui implémente un prix moyen pondéré (« Time Weighted Average Price », dit TWAP). Un [oracle TWAP](https://docs.uniswap.org/contracts/v2/concepts/core-concepts/oracles) interroge le prix d'un actif à deux points différents dans le temps (que vous pouvez modifier) et calcule le prix au comptant en fonction de la moyenne obtenue. Le choix de périodes plus longues protège votre protocole contre la manipulation des prix car les larges ordres exécutés récemment ne peuvent pas affecter les prix des actifs.
-Ceci vous permet de connaître rapidement les problèmes potentiels dans votre code. Comme tous les outils de test automatisés, Slither n'est pas parfait, et peut signaler trop d'erreurs dans le rapport. Il peut avertir d'une éventuelle réentrance, même si aucune vulnérabilité exploitable n'existe. Souvent, l'examen des DIFFERENCES entre les changements de code répertoriées dans le rapport Slither est extrêmement utile, car il aide à découvrir les vulnérabilités introduites beaucoup plus tôt que si vous attendez la fin de votre projet.
+## Ressources de sécurité de contrats intelligents pour les développeurs {#smart-contract-security-resources-for-developers}
-## Complément d'information {#further-reading}
+### Outils pour analyser les contrats intelligents et vérifier la justesse du code {#code-analysis-tools}
-**Guides des bonnes pratiques de sécurité pour les contrats intelligents**
+- **[Outils de test et bibliothèques](/developers/docs/smart-contracts/testing/#testing-tools-and-libraries)** - _Collection d'outils et de bibliothèques standards pour effectuer des tests unitaires, des analyses statiques et des analyses dynamiques des contrats intelligents._
-- [consensys.github.io/smart-contract-best-practices/](https://consensys.github.io/smart-contract-best-practices/)
-- [GitHub](https://github.com/ConsenSys/smart-contract-best-practices/)
-- [Collection agrégée de recommandations de sécurité et de bonnes pratiques](https://github.com/guylando/KnowledgeLists/blob/master/EthereumSmartContracts.md)
+- **[Outils de vérification formels](/developers/docs/smart-contracts/formal-verification/#formal-verification-tools)** - _Outils de vérification de l'exactitude fonctionnelle dans les contrats intelligents et de vérification des invariants._
-**Standard de vérification de la sécurité des contrats intelligents (SCSVS)**
+- **[Services d'audit de contrats intelligents](/developers/docs/smart-contracts/testing/#smart-contract-auditing-services)** - _Liste des organisations fournissant des services d'audit de contrats intelligents pour les projets de développement d'Ethereum._
-- [securing.github.io/SCSVS/](https://securing.github.io/SCSVS/)
+- **[Plateformes de récompenses de bugs](https://ethereum.org/en/developers/docs/smart-contracts/testing/#bug-bounty-platforms)** - _Plateformes pour coordonner les récompenses de bugs et récompensant la divulgation responsable de vulnérabilités critiques dans les contrats intelligents._
-_Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
+- **[Fork Checker](https://forkchecker.hashex.org/)** - _ : Il s'agit d'un outil gratuit en ligne pour la vérification de toutes les informations disponibles concernant un contrat issu du fork._
-## Tutoriels connexes {#related-tutorials}
+- **[ABI Encoder](https://abi.hashex.org/)** - _ : Il s'agit d'un service gratuit en ligne pour l'encodage des fonctions de contrat Solidity et de vos arguments de constructeur._
+
+### Outils de surveillance des contrats intelligents {#smart-contract-monitoring-tools}
+
+- **[Sentinelles de défenseur OpenZeppelin](https://docs.openzeppelin.com/defender/sentinel)** - _Un outil pour surveiller et répondre automatiquement aux événements, fonctions et paramètres de transaction sur vos contrats intelligents._
+
+- **[Alerte en temps réel Tenderly](https://tenderly.co/alerting/)** - _Un outil pour recevoir des notifications en temps réel lorsque des événements inhabituels ou inattendus se produisent sur vos contrats intelligents ou portefeuilles._
+
+### Outils pour une administration sécurisée des contrats intelligents {#smart-contract-administration-tools}
+
+- **[OpenZeppelin Defender Admin](https://docs.openzeppelin.com/defender/admin)** - _Interface pour gérer l'administration des contrats intelligents, y compris les contrôles d'accès, les mises à jour et la pause._
+
+- **[Safe](https://safe.global/)** - _Portefeuille à contrat intelligent fonctionnant sur Ethereum qui exige qu'un nombre minimum de personnes approuvent une transaction avant qu'elle ne puisse avoir lieu (M-of-N)._
+
+- **[Contrats OpenZeppelin](https://docs.openzeppelin.com/contracts/4.x/)** - _Bibliothèques de contrats pour l'implémentation de fonctions administratives, y compris la propriété contractuelle, les mises à niveau, les contrôles d'accès, la gouvernance, les possibilités de pause, et plus encore._
+
+### Services d'audit pour contrat intelligent {#smart-contract-auditing-services}
+
+- **[Diligence ConsenSys](https://consensys.net/diligence/)** - _Service d'audit de contrat intelligent pour aider les projets à travers l'écosystème de la blockchain à s'assurer que leurs protocoles sont prêts à être lancés et construits pour protéger les utilisateurs._
+
+- **[CertiK](https://www.certik.com/)** - _société de sécurité blockchain pionnière dans l'utilisation d'une technologie de vérification formelle de pointe sur les contrats intelligents et les réseaux blockchain._
+
+- **[Trail of Bits](https://www.trailofbits.com/)** - _Entreprise de cybersécurité qui combine la recherche de sécurité avec une mentalité d'attaquant pour réduire le risque et fortifier le code._
+
+- **[PeckShield](https://peckshield.com/)** - _Société de sécurité blockchain offrant des produits et des services pour la sécurité, la confidentialité et la convivialité de l'ensemble de l'écosystème blockchain._
+
+- **[QuantStamp](https://quantstamp.com/)** - _Service d'audit facilitant l'adoption courante de la technologie blockchain par les services de sécurité et d'évaluation des risques._
+
+- **[OpenZeppelin](https://www.openzeppelin.com/security-audits)** - _Société de sécurité de contrat intelligent fournissant des audits de sécurité pour les systèmes distribués._
+
+- **[Vérification de l'exécution](https://runtimeverification.com/)** - _Entreprise de sécurité spécialisée dans la modélisation et la vérification formelles des contrats intelligents._
+
+- **[Hacken](https://hacken.io)** - _Auditeur de cybersécurité Web3 apportant une approche à 360° à la sécurité de la blockchain._
+
+- **[Nethermind](https://nethermind.io/smart-contracts-audits)** - _Des services offrant des audits Cairo et Solidity, utilisés comme garantie pour assurer l'intégrité des contrats intelligents et la sécurité des utilisateurs dans les écosystèmes Ethereum et Starknet._
+
+- **[HashEx](https://hashex.org/)** - _Les rapports d'audit présentés par HashEx relatifs à la blockchain et aux contrats intelligents, visent à garantir la sécurité des cryptomonnaies, fournissant des services tels que le développement des contrats intelligents, le test de pénétration, ou le conseil blockchain._
+
+### Plateformes de récompense de bug {#bug-bounty-platforms}
+
+- **[Immunefi](https://immunefi.com/)** - _Plateforme de récompense de bug pour les contrats intelligents et les projets DeFi, où les chercheurs en sécurité examinent le code, révèlent les vulnérabilités, sont payés et rendent les crypto-monnaies plus sûres._
+
+- **[HackerOne](https://www.hackerone.com/)** - _Coordination de vulnérabilité et plateforme de récompense de bogue qui relie les entreprises aux testeurs de pénétration et aux chercheurs en cybersécurité._
+
+- **[HackenProof](https://hackenproof.com/)** - _Plateforme de récompense de bogue pour les projets de cryptomonnaies (DeFi, contrats intelligents, portefeuilles, CEX et bien plus encore), où les professionnels de la sécurité fournissent des services de triage et les chercheurs sont payés pour des rapports de bogues pertinents et vérifiés._
+
+### Publications de vulnérabilités connues de contrats intelligents et d'exploitations {#common-smart-contract-vulnerabilities-and-exploits}
+
+- **[ConsenSys : Attaques connues sur les contrats intelligents](https://consensys.github.io/smart-contract-best-practices/attacks/)** - _Explication conviviale pour le débutant des vulnérabilités contractuelles les plus significatives, avec le code d'échantillon pour la plupart des cas._
+
+- **[Registre SWC](https://swcregistry.io/)** - _Liste organisée d'éléments d'énumération des faiblesses communes (« Common Weakness Enumeration », dit CWE) qui s'appliquent aux contrats intelligents Ethereum._
+
+- **[Rekt](https://rekt.news/)** - _Publication mise à jour régulière de hacks et d'exploits de cryptomonnaies haut de gamme, ainsi que de rapports détaillés post-mortem._
+
+### Défis pour l'apprentissage de la sécurité des contrats intelligents {#challenges-for-learning-smart-contract-security}
+
+- **[Awesome BlockSec CTF](https://github.com/blockthreat/blocksec-ctfs)** - _Liste organisée des wargames de sécurité de la blockchain, des défis, des concours [Capture The Flag](https://www.webopedia.com/definitions/ctf-event/amp/) concours et des rédactions de solutions._
+
+- **[Damn Vulnerable DeFi](https://www.damnvulnerabledefi.xyz/)** - _Wargame pour apprendre la sécurité offensive des contrats intelligents DeFi et développer des compétences en matière de chasse aux bogues et d'audit de sécurité._
+
+- **[Ethernaut](https://ethernaut.openzeppelin.com/)** - _Wargame basé sur Web3/Solidity où chaque niveau est un contrat intelligent qui doit être « hacké »._
+
+### Meilleures pratiques pour sécuriser les contrats intelligents {#smart-contract-security-best-practices}
+
+- **[Consensys : Meilleures pratiques en termes de sécurité pour les contrats intelligents Ethereum](https://consensys.github.io/smart-contract-best-practices/)** - _Liste complète de lignes directrices pour sécuriser les contrats intelligents Ethereum._
+
+- **[Nascent : Boîte à outils de sécurité simple](https://github.com/nascentxyz/simple-security-toolkit)** - _Collection de guides pratiques axés sur la sécurité et de listes de contrôle pour le développement de contrats intelligents._
+
+- **[Modèles Solidity](https://fravoll.github.io/solidity-patterns/)** -> _Compilation utile de pratiques sécurisées et de meilleures pratiques pour le langage de programmation des contrats intelligents Solidity._
+
+- **[Docs Solidity : considérations en matière de sécurité](https://docs.soliditylang.org/en/v0.8.16/security-considerations.html)** - _Directives pour l'écriture de contrats intelligents sécurisés avec Solidity._
+
+- **[Norme de vérification de la sécurité des contrats intelligents](https://github.com/securing/SCSVS)** - _Liste de contrôle de quatorze parties créée pour standardiser la sécurité des contrats intelligents pour les développeurs, architectes, réviseurs de sécurité et fournisseurs._
+
+### Tutoriels sur la sécurité des contrats intelligents {#tutorials-on-smart-contract-security}
+
+- [Comment écrire des contrats intelligents sécurisés](/developers/tutorials/secure-development-workflow/)
+
+- [Comment utiliser Slither pour trouver des bugs de contrat intelligent](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/)
-- [Flux de développement sécurisé](/developers/tutorials/secure-development-workflow/)
-- [Comment utiliser Slither pour trouver les bogues dans les contrats intelligents](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/)
- [Comment utiliser Manticore pour trouver les bogues dans les contrats intelligents](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/)
-- [Consignes de sécurité](/developers/tutorials/smart-contract-security-guidelines/)
-- [Sécurité des jetons](/developers/tutorials/token-integration-checklist/)
+
+- [Directives de sécurité pour les contrats intelligents](/developers/tutorials/smart-contract-security-guidelines/)
+
+- [Comment intégrer en toute sécurité votre contrat de jetons avec des jetons arbitraires](/developers/tutorials/token-integration-checklist/)
diff --git a/src/content/translations/fr/developers/docs/storage/index.md b/src/content/translations/fr/developers/docs/storage/index.md
index 2fecae6b20b..dc598eaaff2 100644
--- a/src/content/translations/fr/developers/docs/storage/index.md
+++ b/src/content/translations/fr/developers/docs/storage/index.md
@@ -1,10 +1,10 @@
---
title: Stockage décentralisé
-description: Présentation du stockage décentralisé et des outils disponibles à intégrer dans une DApp
+description: Présentation du stockage décentralisé et des outils disponibles à intégrer dans une dApp.
lang: fr
---
-Contrairement à un serveur centralisé exploité par une unique organisation ou une entreprise, les systèmes de stockage décentralisé se composent d'un réseau de pair à pair d'opérateurs-utilisateurs qui détiennent une partie de l'ensemble des données, créant ainsi un système de partage de fichiers résiliant. Cela peut être via une application basée sur la blockchain ou bien sur n'importe quel réseau basé sur le principe du pair à pair.
+Contrairement à un serveur centralisé exploité par une entreprise ou organisation unique, les systèmes de stockage décentralisé se composent d'un réseau de pair à pair d'opérateurs-utilisateurs qui détiennent une partie de l'ensemble des données, créant ainsi un système de partage de fichiers résiliant. Cela peut être via une application basée sur la blockchain ou bien sur n'importe quel réseau basé sur le principe du pair à pair.
Ethereum lui-même peut être utilisé comme un système de stockage décentralisé, c'est d'ailleurs déjà le cas concernant le stockage de code compris dans tous les contrats intelligent. Cependant, lorsqu'il s'agit de grandes quantités de données, Ethereum n'a été conçu pour cela. La chaîne ne cesse de croître, mais au moment d'écrire ces lignes, la chaîne Ethereum est d'environ 500 Go à 1 To ([selon le client](https://etherscan.io/chartsync/chaindefault)), et chaque nœud du réseau doit être en mesure de stocker toutes les données. Si la chaîne devait s'étendre à de grandes quantités de données (disons 5 To par exemple), il serait impossible pour tous les nœuds de continuer à fonctionner. En outre, le coût du déploiement d'une telle quantité de données sur le réseau principal serait prohibitif en raison des frais de [gaz](/developers/docs/gas).
@@ -17,7 +17,7 @@ En se penchant sur la question des options de stockage décentralisé (dStorage)
- Décentralisé
- Consensus
-## Mécanisme de persistance / structure d'incitation {#persistence-mechanism}
+## Mécanisme de persistance / structure incitative {#persistence-mechanism}
### Orientation blockchain {#blockchain-based}
@@ -27,7 +27,7 @@ Ce processus est connu sous le nom de : persistance **basée sur la blockchain**
Le problème avec la persistance basée sur la blockchain est que la chaîne pourrait devenir beaucoup trop grande pour entretenir et stocker toutes les données (ex. [de nombreuses sources](https://healthit.com.au/how-big-is-the-internet-and-how-do-we-measure-it/) estiment que l'Internet nécessite plus de 40 Zetabytes de capacité de stockage).
-La blockchain doit également avoir une certaine structure incitative. Pour la persistance basée sur la blockchain, il y a un paiement effectué au mineur. Lorsque les données sont ajoutées à la chaîne, les nœuds sont payés pour y ajouter les données.
+La blockchain doit également avoir une certaine structure incitative. Pour la persistance basée sur la blockchain, il y a un paiement effectué au validateur. Les validateurs sont payés pour ajouter les données lorsqu'elles sont ajoutées à la chaine.
Plateformes avec persistance basée sur la blockchain :
@@ -46,6 +46,9 @@ Les plateformes avec persistance basée sur contrat :
- [Skynet](https://siasky.net/)
- [Storj](https://storj.io/)
- [0Chain](https://0chain.net/)
+- [Réseau Crust](https://crust.network)
+- [Swarm](https://www.ethswarm.org/)
+- [4EVERLAND](https://www.4everland.org/)
### Autres considérations {#additional-consideration}
@@ -55,6 +58,11 @@ IPFS est un système distribué pour stocker et accéder aux fichiers, sites Web
- [Pinata](https://www.pinata.cloud/) _(service d'épinglage IPFS)_
- [web3.storage](https://web3.storage/) _(service d'épinglage IPFS/Filecoin)_
- [Infura](https://infura.io/product/ipfs) _(service d'épinglage IPFS)_
+- [IPFS Scan](https://ipfs-scan.io) _(explorateur IPFS pinning)_
+- [4EVERLAND](https://www.4everland.org/)_ (service d'épinglage IPFS) _
+- [Filebase](https://filebase.com) _(Service d'épinglage IPFS)_
+
+SWARM est une technologie décentralisée de stockage et de distribution de données avec un système incitatif de stockage et un prix de location de stockage oracle.
## Conservation des données {#data-retention}
@@ -70,6 +78,8 @@ Types de dStorage avec mécanisme de challenge :
- Skynet
- Arweave
- Filecoin
+- Réseau Crust
+- 4EVERLAND
### Décentralisation {#decentrality}
@@ -83,22 +93,24 @@ Outils décentralisés sans KYC :
- Filecoin
- IPFS
- Ethereum
+- Réseau Crust
+- 4EVERLAND
### Consensus {#consensus}
-La plupart de ces outils ont leur propre version de [mécanisme de consensus](/developers/docs/consensus-mechanisms/) mais généralement ils sont basés soit sur une [**Preuve de travail (PoW)**](/developers/docs/consensus-mechanisms/pow/) ou une [**Preuve d'enjeu (PoS)**](/developers/docs/consensus-mechanisms/pos/).
+La plupart de ces outils ont leur propre version de [mécanisme de consensus](/developers/docs/consensus-mechanisms/) mais généralement ils sont basés soit sur une [**Preuve de travail (PoW)**](/developers/docs/consensus-mechanisms/pow/) soit sur une [**Preuve d'enjeu (PoS)**](/developers/docs/consensus-mechanisms/pos/).
-Basé PoW :
+Preuve de travail (PoW) :
- Skynet
- Arweave
-- Ethereum
-Basé PoS :
+Preuve d'enjeu (PoS) :
-- [La chaîne phare](/roadmap/beacon-chain/)
+- Ethereum
- Filecoin
- 0Chain
+- Réseau Crust
## Outils connexes {#related-tools}
@@ -112,6 +124,7 @@ Basé PoS :
- [Storj.io](https://storj.io/)
- [Documentation](https://docs.storj.io/)
+- [GitHub](https://github.com/storj/storj)
**Skynet - _Skynet est une chaîne PoW décentralisée dédiée à un Web décentralisé._**
@@ -131,12 +144,18 @@ Basé PoS :
- [Documentation](https://docs.arweave.org/info/)
- [Arweave](https://github.com/ArweaveTeam/arweave/)
-**0chain - _0Chain est une plateforme dStorage basée Preuve d'enjeu avec des fragments et des blobbers._**
+**0chain - _0Chain est une plateforme dStorage basée sur la Preuve d'enjeu avec des fragments et des blobbers._**
- [0Chain.net](https://0chain.net/)
- [Documentation](https://docs.0chain.net/0chain/)
- [GitHub](https://github.com/0chain/)
+**Réseau Crust - _Crust est une plateforme dStorage basée sur IPFS_**
+
+- [Crust.network](https://crust.network)
+- [Documentation](https://wiki.crust.network)
+- [Github](https://github.com/crustio)
+
**Swarm - _Plateforme de stockage distribuée et service de distribution de contenu pour la pile web3 Ethereum_**
- [EthSwarm.org](https://www.ethswarm.org/)
@@ -161,12 +180,24 @@ Basé PoS :
- [Documentation](https://developers.ceramic.network/learn/welcome/)
- [GitHub](https://github.com/ceramicnetwork/js-ceramic/)
-**Filebase - _La première plate-forme de stockage d'objet compatible S3 qui vous permet de stocker des données sur plusieurs réseaux de stockage décentralisés, y compris IPFS, Sia, Skynet et Storj._**
+**File base - _Stockage décentralisé compatible S3 et service d'épinglage IPFS géo-redondant. Tous les fichiers téléchargés sur IPFS via Filebase sont automatiquement épinglés à l'infrastructure Filebase avec une réplication 3x à travers le monde._**
- [Filebase.com](https://filebase.com/)
- [Documentation](https://docs.filebase.com/)
- [GitHub](https://github.com/filebase)
+**4EVERLAND - _Une plateforme de calcul cloud Web 3 qui intègre les capacités de stockage, de calcul et de réseautage de base, est compatible S3 et fournit un stockage de données synchronisé sur les réseaux de stockage décentralisés tels que IPFS et Arweave._**
+
+- [4everland.org](https://www.4everland.org/)
+- [Documentation](https://docs.4everland.org/)
+- [GitHub](https://github.com/4everland)
+
+**Kaleido - _Une plateforme blockchain-as-a-service avec un bouton clic IPFS Nodes_**
+
+- [Kaleido](https://kaleido.io/)
+- [Documentation](https://docs.kaleido.io/kaleido-services/ipfs/)
+- [GitHub](https://github.com/kaleido-io)
+
## Complément d'information {#further-reading}
- [Qu'est-ce qu'un stockage décentralisé ?](https://coinmarketcap.com/alexandria/article/what-is-decentralized-storage-a-deep-dive-by-filecoin) - _CoinMarketCap_
diff --git a/src/intl/fr/page-languages.json b/src/intl/fr/page-languages.json
index 01bd4aba5df..90b58f1b4fe 100644
--- a/src/intl/fr/page-languages.json
+++ b/src/intl/fr/page-languages.json
@@ -46,6 +46,7 @@
"language-ms": "Malais",
"language-nb": "Norvégien",
"language-nl": "Néerlandais",
+ "language-pcm": "Pidgin Nigérian",
"language-fil": "Philippin",
"language-pl": "Polonais",
"language-pt": "Portugais",
diff --git a/src/intl/fr/page-layer-2.json b/src/intl/fr/page-layer-2.json
index de11b1ae851..8106cdd8498 100644
--- a/src/intl/fr/page-layer-2.json
+++ b/src/intl/fr/page-layer-2.json
@@ -30,7 +30,7 @@
"layer-2-why-do-we-need-layer-2-2": "Ethereum a atteint la capacité actuelle du réseau avec plus d'un million de transactions par jour et une forte demande pour chacune de ces transactions. Le succès d'Ethereum et la demande d'utilisation ont causé une hausse substantielle des prix du gaz. Par conséquent, le besoin de solutions de mise à l'échelle a également augmenté. C'est là que les réseaux de la couche 2 entrent en jeu.",
"layer-2-why-do-we-need-layer-2-scalability": "Évolutivité",
"layer-2-why-do-we-need-layer-2-scalability-1": "L'objectif principal de l'évolutivité est d'augmenter la vitesse des transactions (finalité plus rapide) et le débit des transactions (plus de transactions par seconde) sans sacrifier la décentralisation ou la sécurité.",
- "layer-2-why-do-we-need-layer-2-scalability-2": "La communauté Ethereum a adopté une position ferme : elle ne sacrifiera ni la décentralisation ni la sécurité pour gagner en évolutivité. Jusqu'à l'implémentation de la fragmentation , le réseau principal Ethereum (couche 1) ne peut donc traiter qu'environ 15 transactions par seconde. Lorsque la demande d'utilisation d'Ethereum est élevée, le réseau est encombré, ce qui augmente les frais de transaction et exclut du réseau les utilisateurs qui ne peuvent pas supporter ces frais. C'est sur ce point précis que la couche 2 permettra à Ethereum d'évoluer.",
+ "layer-2-why-do-we-need-layer-2-scalability-2": "La communauté Ethereum a adopté une position ferme : elle ne sacrifiera ni la décentralisation ni la sécurité pour gagner en évolutivité. Jusqu'à l'implémentation de la fragmentation , le réseau principal Ethereum (couche 1) ne peut donc traiter qu'environ 15 transactions par seconde. Lorsque la demande d'utilisation d'Ethereum est élevée, le réseau est encombré, ce qui augmente les frais de transaction et exclut du réseau les utilisateurs qui ne peuvent pas supporter ces frais. C'est sur ce point précis que la couche 2 permettra à Ethereum d'évoluer.",
"layer-2-why-do-we-need-layer-2-scalability-3": "En savoir plus sur la vision d'Ethereum",
"layer-2-benefits-of-layer-2-title": "Les avantages de la couche 2",
"layer-2-lower-fees-title": "Des frais plus bas",
diff --git a/src/intl/fr/page-wallets-find-wallet.json b/src/intl/fr/page-wallets-find-wallet.json
index 935bec891fa..d6c0ac77870 100644
--- a/src/intl/fr/page-wallets-find-wallet.json
+++ b/src/intl/fr/page-wallets-find-wallet.json
@@ -89,5 +89,6 @@
"page-find-wallet-browser": "Navigateur",
"page-find-wallet-browser-desc": "Portefeuilles avec extensions pour navigateur",
"page-find-wallet-device": "Appareil",
- "page-find-choose-to-compare": "Choisir pour comparer"
+ "page-find-choose-to-compare": "Choisir pour comparer",
+ "page-find-wallet-choose-features": "Choisir des fonctionnalités"
}
diff --git a/src/intl/fr/page-what-is-ethereum.json b/src/intl/fr/page-what-is-ethereum.json
index 848b21854e9..b0ab4460b99 100644
--- a/src/intl/fr/page-what-is-ethereum.json
+++ b/src/intl/fr/page-what-is-ethereum.json
@@ -88,10 +88,8 @@
"page-what-is-ethereum-energy-desc-2": "La Fusion a été la plus grande mise à jour d'Ethereum et a réduit la consommation d'énergie nécessaire pour sécuriser Ethereum de 99,5 %, créant ainsi un réseau plus sécurisé pour un coût carbone sensiblement réduit. Ethereum est maintenant une blockchain à faible émission de carbone et à sécurité et évolutivité renforcées.",
"page-what-is-ethereum-more-on-energy-consumption": "En savoir plus sur la consommation d'énergie",
"page-what-is-ethereum-energy-consumption-chart-legend": "Consommation d'énergie annuelle en TWh/an",
- "energy-consumption-chart-youtube-label": "YouTube",
- "energy-consumption-chart-gold-mining-galaxy-label": "Extraction d'or (Galaxy Digital)",
"energy-consumption-chart-global-data-centers-label": "Centres de données globaux",
- "energy-consumption-chart-gold-mining-cbeci-label": "Extraction d'or (CBECI)",
+ "energy-consumption-gold-mining-cbeci-label": "Extraction d'or",
"energy-consumption-chart-btc-pow-label": "BTC PoW",
"energy-consumption-chart-netflix-label": "Netflix",
"energy-consumption-chart-eth-pow-label": "ETH PoW",